using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using PlayerTraders.Core;
using Splatform;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PlayerTraders")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.6.5.0")]
[assembly: AssemblyInformationalVersion("0.6.5")]
[assembly: AssemblyProduct("PlayerTraders")]
[assembly: AssemblyTitle("PlayerTraders")]
[assembly: AssemblyVersion("0.6.5.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PlayerTraders
{
	internal static class DurableSave
	{
		public static void Save()
		{
			Check.That(!SaveSystem.HasSessionFlag((SaveSystemSessionFlags)1) && !ZNet.instance.HardSaveBlock(), "The game blocked character saving; the transaction remains in the journal");
			PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
			playerProfile.SavePlayerData(Player.m_localPlayer);
			Check.That(playerProfile.Save(), "Could not save the character: the transaction is awaiting recovery");
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	internal static class PausePickup
	{
		private static bool Prefix(Humanoid __instance, ref bool __result)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || !Network.Busy)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	internal static class Items
	{
		public static Item Encode(ItemData i, int width = 10)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			return new Item
			{
				Prefab = (Object.op_Implicit((Object)(object)i.m_dropPrefab) ? ((Object)i.m_dropPrefab).name : ((Object)ObjectDB.instance.GetItemPrefab(i.m_shared)).name),
				Count = i.m_stack,
				Max = i.m_shared.m_maxStackSize,
				Quality = i.m_quality,
				Variant = i.m_variant,
				WorldLevel = i.m_worldLevel,
				Durability = i.m_durability,
				Crafter = i.m_crafterID,
				CrafterName = (i.m_crafterName ?? ""),
				PickedUp = i.m_pickedUp,
				Cheated = i.m_cheated,
				Equipped = i.m_equipped,
				Data = new SortedDictionary<string, string>(i.m_customData, StringComparer.Ordinal),
				Slot = i.m_gridPos.y * width + i.m_gridPos.x,
				EquipSlot = EquipmentSlot(i.m_shared.m_itemType)
			};
		}

		public static string EquipmentSlot(ItemType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			if ((int)type <= 7)
			{
				if ((int)type == 6)
				{
					return "Голова";
				}
				if ((int)type == 7)
				{
					return "Торс";
				}
			}
			else
			{
				if ((int)type == 11)
				{
					return "Ноги";
				}
				if ((int)type == 17)
				{
					return "Плечи";
				}
				if ((int)type == 18)
				{
					return "Аксессуар";
				}
			}
			return "";
		}

		public static bool Tradeable(string prefab)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefab);
			ItemDrop val = (Object.op_Implicit((Object)(object)itemPrefab) ? itemPrefab.GetComponent<ItemDrop>() : null);
			if (Object.op_Implicit((Object)(object)val) && prefab != "Coins" && !val.m_itemData.m_shared.m_questItem)
			{
				return (int)val.m_itemData.m_shared.m_itemType != 10;
			}
			return false;
		}

		public static List<Item> KnownItems()
		{
			return (from go in ObjectDB.instance.m_items
				where Object.op_Implicit((Object)(object)go) && Tradeable(((Object)go).name) && Player.m_localPlayer.IsKnownMaterial(go.GetComponent<ItemDrop>().m_itemData.m_shared.m_name)
				select Factory(((Object)go).name)).OrderBy(Name).ToList();
		}

		public static string Description(Item item)
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.Prefab);
			if (!Object.op_Implicit((Object)(object)itemPrefab))
			{
				return "";
			}
			return Localization.instance.Localize(itemPrefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_description);
		}

		public static Item Factory(string prefab)
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefab);
			Check.That(Object.op_Implicit((Object)(object)itemPrefab) && Object.op_Implicit((Object)(object)itemPrefab.GetComponent<ItemDrop>()), "Unknown item: " + prefab);
			ItemData obj = itemPrefab.GetComponent<ItemDrop>().m_itemData.Clone();
			obj.m_dropPrefab = itemPrefab;
			obj.m_stack = 1;
			return Encode(obj).Part(1);
		}

		public static ItemData Decode(Item i, int width = 10)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			i.Validate();
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(i.Prefab);
			Check.That(Object.op_Implicit((Object)(object)itemPrefab) && Object.op_Implicit((Object)(object)itemPrefab.GetComponent<ItemDrop>()), "Game item missing: " + i.Prefab);
			ItemData val = itemPrefab.GetComponent<ItemDrop>().m_itemData.Clone();
			Check.That(i.Max == val.m_shared.m_maxStackSize && i.EquipSlot == EquipmentSlot(val.m_shared.m_itemType), "Item properties do not match the game");
			val.m_dropPrefab = itemPrefab;
			val.m_stack = i.Count;
			val.m_quality = i.Quality;
			val.m_variant = i.Variant;
			val.m_worldLevel = i.WorldLevel;
			val.m_durability = i.Durability;
			val.m_crafterID = i.Crafter;
			val.m_crafterName = i.CrafterName;
			val.m_pickedUp = i.PickedUp;
			val.m_cheated = i.Cheated;
			val.m_equipped = i.Equipped;
			val.m_customData = new Dictionary<string, string>(i.Data);
			val.m_gridPos = new Vector2i(Math.Max(0, i.Slot) % width, Math.Max(0, i.Slot) / width);
			return val;
		}

		public static Bag Snapshot(Inventory inventory)
		{
			Bag bag = new Bag();
			bag.Width = inventory.GetWidth();
			bag.Height = inventory.GetHeight();
			bag.Items = (from i in inventory.GetAllItems()
				select Encode(i, inventory.GetWidth()) into i
				orderby i.Slot
				select i).ToList();
			bag.Validate();
			return bag;
		}

		public static bool Same(Bag a, Bag b)
		{
			return Json.Write(a) == Json.Write(b);
		}

		public static void Validate(Bag bag)
		{
			bag.Validate();
			foreach (Item item in bag.Items)
			{
				Decode(item, bag.Width);
			}
		}

		public static void Apply(Bag before, Bag after)
		{
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			Check.That(Same(Snapshot(inventory), before), "Inventory changed during the transaction; recovery required");
			Check.That(after.Width == inventory.GetWidth() && after.Height == inventory.GetHeight(), "Inventory size changed");
			List<ItemData> source = inventory.GetAllItems().ToList();
			List<ItemData> list = new List<ItemData>();
			foreach (Item i in after.Items.OrderBy((Item x) => x.Slot))
			{
				if (i.Equipped)
				{
					ItemData val = ((IEnumerable<ItemData>)source).SingleOrDefault((Func<ItemData, bool>)((ItemData x) => x.m_equipped && x.m_gridPos.y * after.Width + x.m_gridPos.x == i.Slot));
					Check.That(val != null && Json.Write(Encode(val, after.Width)) == Json.Write(i), "Player equipment changed");
					list.Add(val);
				}
				else
				{
					list.Add(Decode(i, after.Width));
				}
			}
			foreach (ItemData item in source.Where((ItemData x) => x.m_equipped))
			{
				Check.That(list.Contains(item), "Cannot remove an item the player is wearing");
			}
			inventory.GetAllItems().Clear();
			inventory.GetAllItems().AddRange(list);
			AccessTools.Method(typeof(Inventory), "Changed", (Type[])null, (Type[])null).Invoke(inventory, new object[2]
			{
				InventoryNotice.ReceivedCheatedItem(before, after),
				true
			});
		}

		public static string Name(Item i)
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(i.Prefab);
			if (!Object.op_Implicit((Object)(object)itemPrefab))
			{
				return i.Prefab;
			}
			return Localization.instance.Localize(itemPrefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name);
		}

		public static Sprite Icon(Item i)
		{
			return Decode(i).GetIcon();
		}
	}
	internal static class NativeInventoryMove
	{
		public static Inventory Mirror(Bag bag, bool strictStacks = false)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			Inventory val = new Inventory("PlayerTraders", (Sprite)null, bag.Width, bag.Height);
			AccessTools.Field(typeof(Inventory), "m_temoraryInventory").SetValue(val, true);
			foreach (Item item in bag.Items)
			{
				ItemData val2 = Items.Decode(item, bag.Width);
				if (strictStacks)
				{
					val2.m_shared = (SharedData)AccessTools.Method(typeof(object), "MemberwiseClone", (Type[])null, (Type[])null).Invoke(val2.m_shared, null);
					SharedData shared = val2.m_shared;
					shared.m_name = shared.m_name + "#" + item.Key;
				}
				val.GetAllItems().Add(val2);
			}
			return val;
		}

		public static void Apply(Bag player, Bag stock, Request r, bool fillFromTop = false)
		{
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Expected O, but got Unknown
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			string text = Json.Write(new Bag[2] { player, stock });
			Inventory val = Mirror(player, strictStacks: true);
			Inventory val2 = Mirror(stock, strictStacks: true);
			Inventory val3 = ((r.Source == "player") ? val : val2);
			Inventory val4 = ((r.Target == "player") ? val : val2);
			ItemData itemAt = val3.GetItemAt(r.Slot % val3.GetWidth(), r.Slot / val3.GetWidth());
			Check.That(val3 == val4 || !itemAt.m_shared.m_questItem, "This item cannot be given to a trader");
			if (r.TargetSlot < 0)
			{
				Check.That(val3 != val4, "Choose another slot");
				Check.That(r.Count == itemAt.m_stack, "Not enough items");
				if (!fillFromTop)
				{
					val4.MoveItemToThis(val3, itemAt);
				}
				else
				{
					for (int i = 0; i < 2; i++)
					{
						if (itemAt.m_stack <= 0)
						{
							break;
						}
						for (int j = 0; j < val4.GetHeight(); j++)
						{
							if (itemAt.m_stack <= 0)
							{
								break;
							}
							for (int k = 0; k < val4.GetWidth() && itemAt.m_stack > 0; k++)
							{
								ItemData itemAt2 = val4.GetItemAt(k, j);
								bool num;
								if (i != 0)
								{
									num = itemAt2 == null;
								}
								else
								{
									if (itemAt2 == null || !(itemAt2.m_shared.m_name == itemAt.m_shared.m_name))
									{
										continue;
									}
									num = itemAt2.m_stack < itemAt2.m_shared.m_maxStackSize;
								}
								if (num)
								{
									val4.MoveItemToThis(val3, itemAt, itemAt.m_stack, k, j);
								}
							}
						}
					}
				}
			}
			else
			{
				Vector2i val5 = default(Vector2i);
				((Vector2i)(ref val5))..ctor(r.TargetSlot % val4.GetWidth(), r.TargetSlot / val4.GetWidth());
				ItemData itemAt3 = val4.GetItemAt(val5.x, val5.y);
				Check.That(val3 == val4 || itemAt3 == null || !itemAt3.m_shared.m_questItem, "This item cannot be given to a trader");
				GameObject val6 = new GameObject("PT_InventoryCalculation");
				val6.SetActive(false);
				try
				{
					InventoryGrid val7 = val6.AddComponent<InventoryGrid>();
					AccessTools.Field(typeof(InventoryGrid), "m_inventory").SetValue(val7, val4);
					val7.DropItem(val3, itemAt, r.Count, val5);
				}
				finally
				{
					Object.Destroy((Object)(object)val6);
				}
			}
			player.Items = Items.Snapshot(val).Items;
			stock.Items = Items.Snapshot(val2).Items;
			Check.That(text != Json.Write(new Bag[2] { player, stock }), "No space to move the item");
		}

		public static void Place(Bag target, Item item, int slot)
		{
			Check.That(slot >= 0 && slot < target.Capacity, "Duplicate inventory slot");
			Check.That(target.Items.All((Item i) => i.Slot != slot), "Choose an empty slot");
			Bag bag = new Bag
			{
				Width = 1,
				Height = 1
			};
			Item item2 = Json.Copy(item);
			item2.Slot = 0;
			bag.Items.Add(item2);
			Bag beforePlayer = Json.Copy(target);
			Bag beforeStock = Json.Copy(bag);
			Apply(target, bag, new Request
			{
				Source = "stock",
				Target = "player",
				Slot = 0,
				TargetSlot = slot,
				Count = 1
			});
			Check.That(bag.Items.Count == 0, "Not enough space");
			MoveGuard.Verify(beforePlayer, beforeStock, target, bag);
		}
	}
	internal sealed class Wire
	{
		public string Kind;

		public string Text = "";

		public string Session = "";

		public string Actor = "";

		public string Id = "";

		public long World;

		public long Sequence;

		public Dictionary<string, int> Cost;

		public ShopView View;

		public ClientTransfer Transfer;

		public float[] Position;
	}
	internal sealed class ClientTransfer
	{
		public string Id;

		public string Phase;

		public string Trader;

		public long Sequence;

		public Bag Before;

		public Bag After;
	}
	internal sealed class ClientJournal
	{
		public long World;

		public Request Request;

		public ClientTransfer Transfer;

		public bool Applied;
	}
	internal static class Network
	{
		private const string Method = "PT_Request_v1";

		private const string Reply = "PT_Reply_v1";

		public static Ledger Host;

		private static Sessions sessions = new Sessions();

		private static ZNet current;

		private static string hostError;

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

		private static readonly Queue<Action> localQueue = new Queue<Action>();

		private static readonly HashSet<string> actions = new HashSet<string>
		{
			"hello", "ready", "applied", "abort", "close", "open", "heartbeat", "create", "dismantle", "move",
			"prices", "order", "removeOrder", "sell", "fund", "buy", "cash", "look", "equipPlayer", "unequip"
		};

		private static double nextTick;

		private static double nextHello;

		private static double nextHeartbeat;

		private static double lastReply;

		private static double nextPrune;

		public static long World;

		public static long Sequence;

		public static string Actor = "";

		public static string Session = "";

		public static string OpenId = "";

		private static string pendingOpenId = "";

		private static Store clientStore;

		private static ClientJournal journal;

		private static bool clientBlocked;

		public static bool Busy
		{
			get
			{
				if (journal != null)
				{
					if (journal.Request == null)
					{
						return journal.Transfer != null;
					}
					return true;
				}
				return false;
			}
		}

		public static bool BlockInput
		{
			get
			{
				if (Busy && !clientBlocked && Now - lastReply < 12.0 && Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Character)Player.m_localPlayer).IsDead() && Object.op_Implicit((Object)(object)ZNet.instance))
				{
					if (!ZNet.instance.IsServer())
					{
						ZRpc serverRPC = ZNet.instance.GetServerRPC();
						if (serverRPC == null || !serverRPC.IsConnected())
						{
							goto IL_006c;
						}
					}
					return true;
				}
				goto IL_006c;
				IL_006c:
				return TraderUI.Visible;
			}
		}

		public static string LocalActor => Canonical(((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID);

		private static double Now => Time.realtimeSinceStartupAsDouble;

		private static string DataRoot => Path.Combine(Paths.ConfigPath, "PlayerTraders");

		private unsafe static string Canonical(PlatformUserID id)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Check.That(((PlatformUserID)(ref id)).IsValid, "Invalid platform ID");
			Platform platform = id.m_platform;
			return ((object)(*(Platform*)(&platform))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant() + ":" + id.m_userID;
		}

		private static string PeerActor(ZNetPeer peer)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			string hostName = peer.m_socket.GetHostName();
			return Canonical((peer.m_socket is ZSteamSocket) ? new PlatformUserID("Steam", hostName) : new PlatformUserID(hostName));
		}

		public static void Register(ZNetPeer peer)
		{
			peer.m_rpc.Register<ZPackage>("PT_Request_v1", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage package)
			{
				Receive(rpc, package);
			});
			peer.m_rpc.Register<ZPackage>("PT_Reply_v1", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage package)
			{
				if (!Object.op_Implicit((Object)(object)ZNet.instance) || ZNet.instance.IsServer() || ZNet.instance.GetServerRPC() != rpc)
				{
					return;
				}
				try
				{
					Accept(Parse<Wire>(package));
				}
				catch (Exception e)
				{
					Fail(e);
				}
			});
		}

		private static T Parse<T>(ZPackage package)
		{
			return PacketCodec.Read<T>(package);
		}

		private static ZPackage Package(object value)
		{
			return PacketCodec.Create(value);
		}

		private static void SendTo(ZRpc rpc, Wire value)
		{
			ZPackage p = Package(value);
			if (rpc == null)
			{
				localQueue.Enqueue(delegate
				{
					Accept(Parse<Wire>(p));
				});
			}
			else
			{
				rpc.Invoke("PT_Reply_v1", new object[1] { p });
			}
		}

		public static void Send(Request request)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return;
			}
			if (ZNet.instance.IsServer())
			{
				localQueue.Enqueue(delegate
				{
					Receive(null, Package(request));
				});
				return;
			}
			ZRpc serverRPC = ZNet.instance.GetServerRPC();
			if (serverRPC == null || !serverRPC.IsConnected())
			{
				OpenId = "";
				Session = "";
				TraderUI.Close(send: false);
				TraderUI.Notify("Connection lost");
			}
			else
			{
				serverRPC.Invoke("PT_Request_v1", new object[1] { Package(request) });
			}
		}

		public static void Reset()
		{
			TraderUI.Close(send: false);
			current = null;
			Host = null;
			hostError = null;
			sessions = new Sessions();
			requests.Clear();
			localQueue.Clear();
			World = 0L;
			Sequence = 0L;
			Actor = (Session = (OpenId = (pendingOpenId = "")));
			journal = null;
			clientStore = null;
			clientBlocked = false;
			nextTick = (nextHello = (nextHeartbeat = (lastReply = (nextPrune = 0.0))));
			WorldDrops.Reset();
			WorldObjects.Reset();
			Plugin.ResetConfiguration();
		}

		public static void Tick()
		{
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			if (current != ZNet.instance)
			{
				Reset();
				current = ZNet.instance;
			}
			if (localQueue.Count > 0)
			{
				try
				{
					localQueue.Dequeue()();
				}
				catch (Exception e)
				{
					Fail(e);
				}
			}
			if (!Object.op_Implicit((Object)(object)current) || Now < nextTick)
			{
				return;
			}
			nextTick = Now + 1.0;
			if (Now >= nextPrune)
			{
				nextPrune = Now + 60.0;
				string[] array = (from p in requests
					where Now - p.Value > 60.0
					select p.Key).ToArray();
				foreach (string key in array)
				{
					requests.Remove(key);
				}
			}
			if (current.IsServer() && Host == null && hostError == null)
			{
				if (!Object.op_Implicit((Object)(object)ZNetScene.instance) || ZDOMan.instance == null || !Object.op_Implicit((Object)(object)ObjectDB.instance) || !Object.op_Implicit((Object)(object)WorldObjects.TraderPrefab))
				{
					return;
				}
				try
				{
					Plugin.LoadServerConfiguration();
					long worldUID = current.GetWorldUID();
					Check.That(worldUID != 0, "World ID is unavailable");
					string text = Path.Combine(DataRoot, "worlds", worldUID + ".json");
					Store store = new Store(text);
					Host = new Ledger(store, worldUID);
					if (!File.Exists(text))
					{
						store.Save(Host.Data);
					}
					WorldObjects.Reconcile(Host.Data);
					Plugin.LogInfo("Trader registry ready: " + text + "; traders: " + Host.Data.Traders.Count);
				}
				catch (Exception ex)
				{
					Host = null;
					hostError = "Trader storage is locked: " + ex.Message;
					Plugin.Error(ex);
				}
			}
			if (Host != null)
			{
				WorldDrops.Tick();
				sessions.Expire(Now);
				sessions.Prune((string id, string actor) => Host.Data.Traders.TryGetValue(id, out var value) && AliveNear(actor, value.Position));
			}
			if (Plugin.Headless)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || ((Character)Player.m_localPlayer).IsDead())
			{
				TraderUI.Close();
				return;
			}
			TraderMap.Tick();
			if (OpenId.Length > 0 && TraderUI.Visible)
			{
				TraderNPC traderNPC = TraderNPC.Find(OpenId);
				if (!Object.op_Implicit((Object)(object)traderNPC) || Vector3.Distance(((Component)traderNPC).transform.position, ((Component)Player.m_localPlayer).transform.position) > 5f || Now - lastReply > 12.0)
				{
					TraderUI.Close();
					TraderUI.Notify("Connection lost or trader too far away");
				}
				else if (Now >= nextHeartbeat)
				{
					nextHeartbeat = Now + 3.0;
					Send(new Request
					{
						Action = "heartbeat",
						Trader = OpenId,
						Session = Session
					});
				}
			}
			if ((World == 0L || Busy) && Now >= nextHello)
			{
				nextHello = Now + 5.0;
				Send(new Request
				{
					Action = "hello",
					Id = (journal?.Request?.Id ?? journal?.Transfer?.Id ?? "")
				});
			}
		}

		private static (string actor, string name, Vector3 position, long character) Identity(ZRpc rpc)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (rpc == null)
			{
				Check.That(ZNet.instance.IsServer() && Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Character)Player.m_localPlayer).IsDead(), "Player unavailable");
				return (actor: LocalActor, name: Player.m_localPlayer.GetPlayerName(), position: ((Component)Player.m_localPlayer).transform.position, character: CharacterAccess.Require(Player.m_localPlayer.GetPlayerID()));
			}
			ZNetPeer val = ((IEnumerable<ZNetPeer>)ZNet.instance.GetPeers()).SingleOrDefault((Func<ZNetPeer, bool>)((ZNetPeer x) => x.m_rpc == rpc));
			Check.That(val != null && val.IsReady() && rpc.IsConnected(), "Connection not confirmed");
			string text = PeerActor(val);
			Check.That(!string.IsNullOrWhiteSpace(text) && text.Length <= 256, "Connection owner is unavailable");
			ZDO zDO = ZDOMan.instance.GetZDO(val.m_characterID);
			Check.That(zDO != null && !zDO.GetBool("dead", false), "Character unavailable");
			long item = CharacterAccess.Require(zDO.GetLong(ZDOVars.s_playerID, 0L));
			return (actor: text, name: val.m_playerName, position: zDO.GetPosition(), character: item);
		}

		private static bool AliveNear(string actor, float[] position)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && actor == LocalActor)
				{
					return !((Character)Player.m_localPlayer).IsDead() && Vector3.Distance(((Component)Player.m_localPlayer).transform.position, Vec(position)) <= 5f;
				}
				ZNetPeer val = ((IEnumerable<ZNetPeer>)ZNet.instance.GetPeers()).FirstOrDefault((Func<ZNetPeer, bool>)((ZNetPeer p) => p.IsReady() && PeerActor(p) == actor));
				if (val == null)
				{
					return false;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(val.m_characterID);
				return zDO != null && !zDO.GetBool("dead", false) && Vector3.Distance(zDO.GetPosition(), Vec(position)) <= 5f;
			}
			catch
			{
				return false;
			}
		}

		public static Vector3 Vec(float[] p)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Check.That(p != null && p.Length == 3 && p.All((float x) => !float.IsNaN(x) && !float.IsInfinity(x)), "Invalid position");
			return new Vector3(p[0], p[1], p[2]);
		}

		private static ClientTransfer ClientPart(Transfer p)
		{
			return new ClientTransfer
			{
				Id = p.Id,
				Sequence = p.Sequence,
				Phase = p.Phase,
				Before = p.PlayerBefore,
				After = p.PlayerAfter,
				Trader = p.After.Id
			};
		}

		private static ShopView View(Trader t, string actor, long character)
		{
			return ShopView.For(t, actor, character);
		}

		private static void Receive(ZRpc rpc, ZPackage package)
		{
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_09df: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a18: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aae: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ZNet.instance) || !ZNet.instance.IsServer())
			{
				return;
			}
			string text = "";
			string key = "";
			try
			{
				(string, string, Vector3, long) tuple = Identity(rpc);
				key = tuple.Item1;
				Request r = Parse<Request>(package);
				text = r.Id;
				Check.That(hostError == null && Host != null, hostError ?? "The world is still loading");
				Host.Data.Pending.TryGetValue(key, out var value);
				CharacterAccess.CheckPending(value, tuple.Item4);
				Check.That(r.Action != null && actions.Contains(r.Action) && (r.Trader?.Length ?? 0) <= 64 && (r.Session?.Length ?? 0) <= 64 && (r.Id?.Length ?? 0) <= 64 && (r.Key?.Length ?? 0) <= 128, "Invalid request");
				string key2 = tuple.Item1 + ":" + r.Action;
				Check.That(!requests.TryGetValue(key2, out var value2) || Now - value2 >= 0.12, "Too many requests");
				requests[key2] = Now;
				if (r.Action == "dismantle")
				{
					if (rpc == null && !Host.Data.Traders.ContainsKey(r.Trader) && !Host.Data.Drops.ContainsKey(r.Trader) && WorldObjects.RemoveOrphan(r.Trader, tuple.Item3, out var removedPosition))
					{
						SendTo(rpc, new Wire
						{
							Kind = "removed",
							Id = r.Trader,
							Position = new float[3] { removedPosition.x, removedPosition.y, removedPosition.z },
							Text = "Removed a trader with missing data. Its belongings are not in the registry."
						});
						return;
					}
					bool flag = false;
					DropPlan dropPlan;
					if (Host.Data.Drops.TryGetValue(r.Trader, out var value3))
					{
						Check.That(value3.Owner == tuple.Item1 && value3.OwnerCharacter == tuple.Item4 && Vector3.Distance(tuple.Item3, Vec(value3.Position)) <= 5f, "Only the owner can do this");
						dropPlan = value3;
					}
					else
					{
						Check.That(Host.Data.Traders.TryGetValue(r.Trader, out var value4), "Trader not found");
						Check.That(value4.IsOwner(tuple.Item1, tuple.Item4) && Vector3.Distance(tuple.Item3, Vec(value4.Position)) <= 5f, "Only the owner can do this");
						string token = sessions.Open(r.Trader, tuple.Item1, Now);
						sessions.Check(r.Trader, tuple.Item1, token, Now);
						WorldObjects.ValidateDrops(DropPlan.From(value4));
						dropPlan = Host.Dismantle(r.Trader, tuple.Item1, r.Revision, tuple.Item4);
						flag = true;
					}
					WorldObjects.ApplyDrops(dropPlan);
					sessions.Close(r.Trader, tuple.Item1);
					SendTo(rpc, new Wire
					{
						Kind = "removed",
						Id = r.Trader,
						Position = (flag ? dropPlan.Position : null)
					});
					return;
				}
				if (r.Action == "hello")
				{
					Host.Data.Receipts.TryGetValue(tuple.Item1, out var value5);
					Host.Data.Pending.TryGetValue(tuple.Item1, out var value6);
					SendTo(rpc, new Wire
					{
						Kind = "hello",
						Actor = tuple.Item1,
						World = Host.Data.World,
						Sequence = (value5?.Sequence ?? 0),
						Id = (value5?.Id ?? ""),
						Cost = Plugin.Cost,
						Transfer = ((value6 == null) ? null : ClientPart(value6))
					});
					return;
				}
				if (r.Action == "ready" || r.Action == "applied" || r.Action == "abort")
				{
					if (r.Action == "ready")
					{
						Check.That(Host.Data.Pending.TryGetValue(tuple.Item1, out var value7) && value7.Id == r.Id, "Transaction not found");
						if (value7.Phase == "prepared" && Vector3.Distance(tuple.Item3, Vec((value7.Action == "create") ? value7.After.Position : value7.Before.Position)) > 5f)
						{
							Host.Abort(tuple.Item1, r.Id);
							SendTo(rpc, new Wire
							{
								Kind = "aborted",
								Id = r.Id,
								Sequence = Host.Data.Receipts[tuple.Item1].Sequence
							});
						}
						else
						{
							Transfer transfer = Host.Commit(tuple.Item1, r.Id);
							WorldObjects.Apply(transfer.After);
							SendTo(rpc, new Wire
							{
								Kind = "commit",
								Transfer = ClientPart(transfer)
							});
						}
					}
					else if (r.Action == "abort")
					{
						Host.Abort(tuple.Item1, r.Id);
						SendTo(rpc, new Wire
						{
							Kind = "done",
							Id = r.Id,
							Sequence = Host.Data.Receipts[tuple.Item1].Sequence
						});
					}
					else
					{
						Host.Data.Pending.TryGetValue(tuple.Item1, out var value8);
						Host.Applied(tuple.Item1, r.Id);
						Wire wire = new Wire
						{
							Kind = "done",
							Id = r.Id,
							Sequence = Host.Data.Receipts[tuple.Item1].Sequence
						};
						if (value8 != null && value8.After.Place == PlaceState.Placed)
						{
							wire.View = View(value8.After, tuple.Item1, tuple.Item4);
						}
						SendTo(rpc, wire);
					}
					return;
				}
				if (r.Action == "close")
				{
					sessions.Close(r.Trader, tuple.Item1);
					return;
				}
				if (!string.IsNullOrEmpty(r.Id) && Host.Data.Pending.TryGetValue(tuple.Item1, out var value9) && value9.Id == r.Id)
				{
					SendTo(rpc, new Wire
					{
						Kind = ((value9.Phase == "prepared") ? "prepare" : "commit"),
						Transfer = ClientPart(value9)
					});
					return;
				}
				if (!string.IsNullOrEmpty(r.Id) && Host.Data.Receipts.TryGetValue(tuple.Item1, out var value10) && value10.Id == r.Id)
				{
					SendTo(rpc, new Wire
					{
						Kind = "done",
						Id = r.Id,
						Sequence = value10.Sequence
					});
					return;
				}
				Trader value11 = null;
				if (r.Action != "create")
				{
					Check.That(Host.Data.Traders.TryGetValue(r.Trader, out value11), "Trader not found");
				}
				if (r.Action == "create")
				{
					Check.That(Vector3.Distance(tuple.Item3, Vec(r.Position)) <= 5f, "Too far away to build");
					Check.That(!Location.IsInsideNoBuildLocation(Vec(r.Position)), "Building is not allowed here");
					Check.That(Math.Abs(r.Position[0]) < 20000f && Math.Abs(r.Position[2]) < 20000f && r.Position[1] > -1000f && r.Position[1] < 10000f, "Invalid placement");
				}
				else
				{
					Check.That(value11.Place == PlaceState.Placed && Vector3.Distance(tuple.Item3, Vec(value11.Position)) <= 5f, "Too far from the trader");
				}
				if (r.Action == "open")
				{
					Check.That(!Host.Data.Pending.Values.Any((Transfer p) => p.After.Id == r.Trader), "The trader has an unfinished transaction");
					string session = sessions.Open(r.Trader, tuple.Item1, Now);
					SendTo(rpc, new Wire
					{
						Kind = "view",
						Session = session,
						View = View(value11, tuple.Item1, tuple.Item4)
					});
					return;
				}
				if (r.Action != "create")
				{
					sessions.Check(r.Trader, tuple.Item1, r.Session, Now);
				}
				if (r.Action == "heartbeat")
				{
					SendTo(rpc, new Wire
					{
						Kind = "heartbeat"
					});
					return;
				}
				Items.Validate(r.Inventory);
				if (r.Action == "look")
				{
					WorldObjects.ValidateLook(r.Look);
				}
				if (r.Action == "order")
				{
					Check.That(Items.Tradeable(r.Key), "This item cannot be purchased");
				}
				if (r.Action == "sell")
				{
					Check.That(Items.Tradeable(r.Key), "This item cannot be given to a trader");
				}
				Transfer transfer2 = new Rules(Items.Factory)
				{
					NativeMove = NativeInventoryMove.Apply,
					NativePlace = NativeInventoryMove.Place,
					ConstructionCost = Plugin.Cost
				}.Prepare(Host.Data, tuple.Item1, tuple.Item2, r, (r.Action == "create") ? WorldObjects.RandomLook() : null, tuple.Item4);
				Package(new Wire
				{
					Kind = "prepare",
					Transfer = ClientPart(transfer2)
				});
				Host.Prepare(transfer2);
				SendTo(rpc, new Wire
				{
					Kind = "prepare",
					Transfer = ClientPart(transfer2)
				});
			}
			catch (Exception ex)
			{
				if (!(ex is RuleException))
				{
					Plugin.Error(ex);
				}
				Receipt value12;
				bool flag2 = !string.IsNullOrEmpty(text) && Host != null && !Host.Data.Pending.ContainsKey(key) && (!Host.Data.Receipts.TryGetValue(key, out value12) || value12.Id != text);
				SendTo(rpc, new Wire
				{
					Kind = (flag2 ? "rejected" : "error"),
					Id = text,
					Text = ((ex is RuleException) ? ex.Message : "Operation failed. Check the log; no duplicate items were delivered.")
				});
			}
		}

		public static void Open(string id)
		{
			if (Busy || clientBlocked)
			{
				TraderUI.Notify("Recover the unfinished transaction first");
				return;
			}
			pendingOpenId = id;
			Send(new Request
			{
				Action = "open",
				Trader = id
			});
		}

		private static void RefreshOpenView(ShopView updated = null)
		{
			if (TraderUI.Visible && !Busy && OpenId.Length != 0)
			{
				if (updated != null && updated.Id == OpenId)
				{
					TraderUI.Show(updated);
				}
				else
				{
					Open(OpenId);
				}
			}
		}

		public static void Close()
		{
			if (OpenId.Length > 0)
			{
				Send(new Request
				{
					Action = "close",
					Trader = OpenId,
					Session = Session
				});
			}
			OpenId = "";
			Session = "";
			pendingOpenId = "";
		}

		public static void Operate(Request r)
		{
			try
			{
				Check.That(World != 0L && clientStore != null, "The trader is still loading. Please try again in a moment.");
				Check.That(!clientBlocked, "Wait for the connection or transaction recovery");
				Check.That(!Busy, "Wait for the operation to finish");
				r.Id = Guid.NewGuid().ToString("N");
				r.Sequence = checked(Sequence + 1);
				r.Session = Session;
				r.Inventory = Items.Snapshot(((Humanoid)Player.m_localPlayer).GetInventory());
				Package(r);
				journal = new ClientJournal
				{
					World = World,
					Request = r
				};
				clientStore.Save(journal);
				Send(r);
			}
			catch (Exception e)
			{
				Fail(e);
			}
		}

		private static void Accept(Wire wire)
		{
			lastReply = Now;
			try
			{
				if (wire.Kind == "hello")
				{
					if (World == 0L)
					{
						World = wire.World;
						Actor = wire.Actor;
						clientStore = new Store(Path.Combine(DataRoot, "clients", Json.Hash(Actor + ":" + Player.m_localPlayer.GetPlayerID()) + "_" + World + ".json"));
						if (File.Exists(clientStore.Path))
						{
							journal = clientStore.Load<ClientJournal>();
							Check.That(journal.World == World, "The journal belongs to another world");
						}
						else
						{
							Check.That(!File.Exists(clientStore.Path + ".bak") && !File.Exists(clientStore.Path + ".tmp"), "Client journal missing; a backup was found");
						}
					}
					Check.That(World == wire.World && Actor == wire.Actor, "The world or connection changed");
					Sequence = wire.Sequence;
					if (wire.Cost != null)
					{
						WorldObjects.SetBuildCost(wire.Cost);
					}
					if (wire.Transfer != null)
					{
						ProcessTransfer(wire.Transfer);
					}
					else if (Busy)
					{
						string text = journal.Request?.Id ?? journal.Transfer?.Id;
						if (wire.Id == text)
						{
							Finish(text, wire.Sequence);
							RefreshOpenView();
						}
						else
						{
							if (journal.Transfer != null)
							{
								throw new RuleException("The host does not recognise the recorded transaction: a save rollback may have occurred. Automatic recovery blocked.");
							}
							Check.That(Items.Same(Items.Snapshot(((Humanoid)Player.m_localPlayer).GetInventory()), journal.Request.Inventory), "Inventory changed before confirmation. Transaction blocked for inspection.");
							Send(journal.Request);
						}
					}
				}
				else if (wire.Kind == "view")
				{
					if (wire.View.Id != pendingOpenId && wire.View.Id != OpenId)
					{
						return;
					}
					pendingOpenId = "";
					OpenId = wire.View.Id;
					Session = wire.Session;
					TraderUI.Show(wire.View);
				}
				else if (wire.Kind == "removed")
				{
					if (OpenId == wire.Id)
					{
						TraderUI.Close();
					}
					if (wire.Position != null)
					{
						WorldObjects.HammerEffects(wire.Position, 0f, removed: true);
					}
					TraderUI.Notify(string.IsNullOrEmpty(wire.Text) ? "Trader dismantled" : wire.Text);
				}
				else if (wire.Kind == "prepare" || wire.Kind == "commit")
				{
					ProcessTransfer(wire.Transfer);
				}
				else if (wire.Kind == "done")
				{
					Finish(wire.Id, wire.Sequence);
					RefreshOpenView(wire.View);
				}
				else if (wire.Kind == "aborted")
				{
					if (Busy && (journal.Request?.Id ?? journal.Transfer?.Id) == wire.Id)
					{
						journal = new ClientJournal
						{
							World = World
						};
						Sequence = wire.Sequence;
						clientStore.Save(journal);
						TraderUI.Notify("You moved away from the trader. The operation was cancelled; your items are unchanged.");
					}
				}
				else if (wire.Kind == "rejected")
				{
					if (Busy && journal.Transfer == null && journal.Request.Id == wire.Id)
					{
						Request request = journal.Request;
						Plugin.Warn("Operation rejected: " + request.Action + " " + request.Source + ":" + request.Slot + " → " + request.Target + ":" + request.TargetSlot + "; " + wire.Text);
						journal = new ClientJournal
						{
							World = World
						};
						clientStore.Save(journal);
						RefreshOpenView();
					}
					TraderUI.Notify(wire.Text);
				}
				else if (wire.Kind == "error")
				{
					TraderUI.Notify(wire.Text);
					if (!Busy && OpenId.Length > 0 && wire.Text.Contains("Session"))
					{
						TraderUI.Close();
					}
					if (Busy && journal.Transfer == null && wire.Id == journal.Request.Id)
					{
						Send(new Request
						{
							Action = "hello",
							Id = wire.Id
						});
					}
				}
			}
			catch (Exception e)
			{
				if (wire.Kind == "prepare" || wire.Kind == "commit" || wire.Kind == "hello" || wire.Kind == "done")
				{
					clientBlocked = true;
				}
				Fail(e);
			}
			TraderUI.RefreshInput();
		}

		private static void ProcessTransfer(ClientTransfer tx)
		{
			if (tx.Sequence > Sequence)
			{
				Check.That(!clientBlocked, "Recovery blocked; see the log");
				Check.That(!Busy || (journal.Request?.Id ?? journal.Transfer?.Id) == tx.Id, "Another transaction is awaiting recovery");
				if (journal == null)
				{
					journal = new ClientJournal
					{
						World = World
					};
				}
				journal.Transfer = tx;
				clientStore.Save(journal);
				string key = "PT.receipt." + World;
				Player localPlayer = Player.m_localPlayer;
				Bag a = Items.Snapshot(((Humanoid)localPlayer).GetInventory());
				string value;
				switch (Recovery.Decide(tx.Phase, localPlayer.m_customData.TryGetValue(key, out value) && value == tx.Id, Items.Same(a, tx.Before)))
				{
				case RecoveryStep.Acknowledge:
					Check.That(tx.Phase == "committed", "The character receipt does not match the host journal");
					DurableSave.Save();
					journal.Applied = true;
					clientStore.Save(journal);
					Send(new Request
					{
						Action = "applied",
						Id = tx.Id
					});
					break;
				case RecoveryStep.Abort:
					journal.Transfer = null;
					journal.Request = new Request
					{
						Id = tx.Id,
						Sequence = tx.Sequence,
						Inventory = tx.Before,
						Action = "abort"
					};
					clientStore.Save(journal);
					Send(new Request
					{
						Action = "abort",
						Id = tx.Id
					});
					break;
				case RecoveryStep.Ready:
					Send(new Request
					{
						Action = "ready",
						Id = tx.Id
					});
					break;
				default:
					Items.Apply(tx.Before, tx.After);
					localPlayer.m_customData[key] = tx.Id;
					DurableSave.Save();
					journal.Applied = true;
					clientStore.Save(journal);
					Send(new Request
					{
						Action = "applied",
						Id = tx.Id
					});
					break;
				}
			}
		}

		private static void Finish(string id, long sequence)
		{
			if (Busy && sequence <= Sequence && (journal.Request?.Id ?? journal.Transfer?.Id) != id)
			{
				return;
			}
			if (!Busy)
			{
				Sequence = Math.Max(Sequence, sequence);
				return;
			}
			Check.That((journal.Request?.Id ?? journal.Transfer?.Id) == id, "Transaction receipt mismatch");
			if (journal.Transfer != null)
			{
				Check.That(Player.m_localPlayer.m_customData.TryGetValue("PT.receipt." + World, out var value) && value == id, "Character receipt missing; recovery required");
			}
			if (journal.Request != null)
			{
				TraderUI.Traded(journal.Request.Trader, journal.Request.Action);
			}
			Request request = ((journal.Applied && journal.Request != null && journal.Request.Action == "create") ? journal.Request : null);
			Sequence = sequence;
			journal = new ClientJournal
			{
				World = World
			};
			clientStore.Save(journal);
			TraderUI.Notify("Done");
			if (request != null)
			{
				WorldObjects.HammerEffects(request.Position, request.Yaw, removed: false);
			}
		}

		public static void Fail(Exception e)
		{
			if (!(e is RuleException))
			{
				Plugin.Error(e);
			}
			TraderUI.Notify((e is RuleException) ? e.Message : ("Error: " + e.Message));
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal static class RegisterRpc
	{
		private static void Postfix(ZNetPeer peer)
		{
			Network.Register(peer);
		}
	}
	internal static class PacketCodec
	{
		public const int Limit = 1048576;

		public static ZPackage Create(object value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			string text = Json.Write(value);
			Check.That(Encoding.UTF8.GetByteCount(text) < 1048544, "Too much custom item data");
			ZPackage val = new ZPackage();
			val.Write(text);
			val.SetPos(0);
			return val;
		}

		public static T Read<T>(ZPackage package)
		{
			Check.That(package.Size() > 0 && package.Size() <= 1048576, "The network message is too large");
			package.SetPos(0);
			try
			{
				return Json.Read<T>(package.ReadString());
			}
			catch (EndOfStreamException)
			{
				throw new RuleException("Could not read trader network data. Please try again.");
			}
		}
	}
	internal static class TraderAppearance
	{
		public static void Write(ZDO z, Look look, Dictionary<string, Item> equipment)
		{
			Publish(look, equipment, delegate(int key, int value)
			{
				z.Set(key, value, false);
			}, delegate(int key, Vector3 value)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				z.Set(key, value);
			});
		}

		internal static void Publish(Look look, Dictionary<string, Item> equipment, Action<int, int> number, Action<int, Vector3> color)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			number(ZDOVars.s_modelIndex, look.Body);
			color(ZDOVars.s_skinColor, new Vector3(look.Skin[0], look.Skin[1], look.Skin[2]));
			color(ZDOVars.s_hairColor, new Vector3(look.HairColor[0], look.HairColor[1], look.HairColor[2]));
			number(ZDOVars.s_hairItem, Hash(look.Hair));
			number(ZDOVars.s_beardItem, Hash(look.Beard));
			number(ZDOVars.s_helmetItem, Hash(Slot("Голова")?.Prefab));
			number(ZDOVars.s_chestItem, Hash(Slot("Торс")?.Prefab));
			number(ZDOVars.s_legItem, Hash(Slot("Ноги")?.Prefab));
			number(ZDOVars.s_utilityItem, Hash(Slot("Аксессуар")?.Prefab));
			Item item = Slot("Плечи");
			number(ZDOVars.s_shoulderItem, Hash(item?.Prefab));
			number(ZDOVars.s_shoulderItemVariant, item?.Variant ?? 0);
			number(ZDOVars.s_shoulderItemQuality, item?.Quality ?? 1);
			static int Hash(string prefab)
			{
				if (!string.IsNullOrEmpty(prefab))
				{
					return StringExtensionMethods.GetStableHashCode(prefab);
				}
				return 0;
			}
			Item Slot(string slot)
			{
				if (equipment == null || !equipment.TryGetValue(slot, out var value))
				{
					return null;
				}
				return value;
			}
		}
	}
	internal static class TraderMap
	{
		private sealed class Entry
		{
			public ZDOID Id;

			public string Name;

			public Vector3 Position;

			public PinData Pin;
		}

		private static readonly Dictionary<ZDOID, Entry> known = new Dictionary<ZDOID, Entry>();

		private static Minimap map;

		private static Sprite icon;

		public static void Observe(ZDO z, string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (z == null || z.GetBool("PT.dropped", false) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			if (!known.TryGetValue(z.m_uid, out var value))
			{
				Dictionary<ZDOID, Entry> dictionary = known;
				ZDOID uid = z.m_uid;
				Entry obj = new Entry
				{
					Id = z.m_uid
				};
				value = obj;
				dictionary.Add(uid, obj);
			}
			if (value.Name != name && value.Pin != null)
			{
				if (Object.op_Implicit((Object)(object)map))
				{
					map.RemovePin(value.Pin);
				}
				value.Pin = null;
			}
			value.Name = name;
			value.Position = z.GetPosition();
		}

		public static void Tick()
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Minimap.instance) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			if ((Object)(object)map != (Object)(object)Minimap.instance)
			{
				if (Object.op_Implicit((Object)(object)map))
				{
					Reset();
				}
				map = Minimap.instance;
			}
			if (known.Count == 0)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)icon))
			{
				icon = map.m_locationIcons.Select((LocationSpriteData x) => x.m_icon).FirstOrDefault((Func<Sprite, bool>)((Sprite s) => Object.op_Implicit((Object)(object)s) && ((Object)s).name == "mapicon_trader"));
			}
			if (!Object.op_Implicit((Object)(object)icon))
			{
				return;
			}
			foreach (Entry value in known.Values)
			{
				if (value.Pin == null)
				{
					value.Pin = map.AddPin(value.Position, (PinType)8, value.Name, false, false, 0L, default(PlatformUserID));
					value.Pin.m_icon = icon;
					value.Pin.m_doubleSize = true;
				}
			}
		}

		public static void Remove(ZDOID id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (known.TryGetValue(id, out var value))
			{
				if (Object.op_Implicit((Object)(object)map) && value.Pin != null)
				{
					map.RemovePin(value.Pin);
				}
				known.Remove(id);
			}
		}

		public static void Reset()
		{
			if (Object.op_Implicit((Object)(object)map))
			{
				foreach (Entry value in known.Values)
				{
					if (value.Pin != null)
					{
						map.RemovePin(value.Pin);
					}
				}
			}
			known.Clear();
			map = null;
			icon = null;
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "OnZDODestroyed")]
	internal static class RemoveTraderMapPin
	{
		private static void Prefix(ZDO __0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			TraderMap.Remove(__0.m_uid);
		}
	}
	public sealed class TraderMaterials : MonoBehaviour
	{
		private Material[] owned;

		internal void Initialize(Renderer body)
		{
			if (owned == null && Object.op_Implicit((Object)(object)body))
			{
				owned = body.materials;
			}
		}

		private void OnDestroy()
		{
			if (owned != null)
			{
				Material[] array = owned;
				foreach (Material val in array)
				{
					if (Object.op_Implicit((Object)(object)val))
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
			owned = null;
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "Awake")]
	internal static class TraderMaterialOwnership
	{
		private static bool Prefix(VisEquipment __instance)
		{
			if (!Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<TraderNPC>()))
			{
				return true;
			}
			if (Plugin.Headless)
			{
				return false;
			}
			if (!Object.op_Implicit((Object)(object)__instance.m_bodyModel))
			{
				return true;
			}
			(((Component)__instance).gameObject.GetComponent<TraderMaterials>() ?? ((Component)__instance).gameObject.AddComponent<TraderMaterials>()).Initialize((Renderer)(object)__instance.m_bodyModel);
			return true;
		}
	}
	public sealed class TraderOfferMarker : MonoBehaviour
	{
		private const float VisibilityDistance = 50f;

		private static Sprite sprite;

		private Transform face;

		private void Awake()
		{
			((Behaviour)this).enabled = false;
		}

		internal void Refresh(Appearance appearance)
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			bool flag = false;
			if (Object.op_Implicit((Object)(object)localPlayer) && !((Character)localPlayer).IsDead() && Network.World != 0L && appearance != null)
			{
				Vector3 val = ((Component)localPlayer).transform.position - ((Component)this).transform.position;
				if (((Vector3)(ref val)).sqrMagnitude <= 2500f)
				{
					localPlayer.m_customData.TryGetValue(OfferNews.Key(Network.World, appearance.Id), out var value);
					flag = OfferNews.Unread(appearance.OfferRevision, value);
				}
			}
			if (flag && !Object.op_Implicit((Object)(object)face))
			{
				if (!Object.op_Implicit((Object)(object)sprite))
				{
					Texture2D val2 = NativeWidgets.LoadTexture("offer-new.png");
					sprite = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f), (float)((Texture)val2).height / 0.7f);
				}
				GameObject val3 = new GameObject("NewTradeOffers");
				face = val3.transform;
				face.SetParent(((Component)this).transform, false);
				face.localPosition = new Vector3(0f, 2.55f, 0f);
				SpriteRenderer obj = val3.AddComponent<SpriteRenderer>();
				obj.sprite = sprite;
				((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)obj).receiveShadows = false;
			}
			if (Object.op_Implicit((Object)(object)face))
			{
				((Component)face).gameObject.SetActive(flag);
			}
			((Behaviour)this).enabled = flag;
		}

		private void LateUpdate()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			if (Object.op_Implicit((Object)(object)face) && Object.op_Implicit((Object)(object)main))
			{
				face.rotation = ((Component)main).transform.rotation;
			}
		}

		internal static void Viewed(ShopView view)
		{
			Player localPlayer = Player.m_localPlayer;
			if (view == null || !Object.op_Implicit((Object)(object)localPlayer) || Network.World == 0L)
			{
				return;
			}
			string key = OfferNews.Key(Network.World, view.Id);
			localPlayer.m_customData.TryGetValue(key, out var value);
			if (OfferNews.Unread(view.OfferRevision, value))
			{
				localPlayer.m_customData[key] = OfferNews.Remember(view.OfferRevision, value);
				TraderNPC traderNPC = TraderNPC.Find(view.Id);
				if (Object.op_Implicit((Object)(object)traderNPC))
				{
					((Component)traderNPC).GetComponent<TraderOfferMarker>()?.Refresh(traderNPC.Current);
				}
			}
		}

		internal static void ReleaseAssets()
		{
			if (Object.op_Implicit((Object)(object)sprite))
			{
				Texture2D texture = sprite.texture;
				Object.Destroy((Object)(object)sprite);
				if (Object.op_Implicit((Object)(object)texture))
				{
					Object.Destroy((Object)(object)texture);
				}
			}
			sprite = null;
		}
	}
	internal static class TraderPose
	{
		public static void Stand(Animator animator)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)animator))
			{
				return;
			}
			AnimatorCullingMode cullingMode = animator.cullingMode;
			animator.cullingMode = (AnimatorCullingMode)0;
			animator.fireEvents = false;
			animator.applyRootMotion = false;
			animator.Update(0f);
			AnimatorControllerParameter[] parameters = animator.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				if ((int)val.type == 9)
				{
					animator.ResetTrigger(val.nameHash);
				}
				if ((int)val.type == 4 && (val.name == "wakeup" || val.name == "intro" || val.name == "sleeping" || val.name == "sitting" || val.name == "attached"))
				{
					animator.SetBool(val.nameHash, false);
				}
			}
			for (int j = 0; j < 4; j++)
			{
				animator.Update(5f);
			}
			animator.cullingMode = cullingMode;
		}
	}
	internal static class WorldDrops
	{
		private sealed class Snapshot
		{
			public WeakReference<Ledger> Ledger;

			public string[] Ids;
		}

		private static volatile Snapshot prepared;

		[ThreadStatic]
		private static Snapshot saving;

		private static readonly ConcurrentQueue<Snapshot> completed = new ConcurrentQueue<Snapshot>();

		public static void Capture()
		{
			Ledger host = Network.Host;
			prepared = ((host == null) ? null : new Snapshot
			{
				Ledger = new WeakReference<Ledger>(host),
				Ids = host.Data.Drops.Keys.Where(WorldObjects.DropDelivered).ToArray()
			});
		}

		public static void Begin()
		{
			saving = prepared;
		}

		public static void End(bool success)
		{
			if (success && saving != null && saving.Ids.Length != 0)
			{
				completed.Enqueue(saving);
			}
			saving = null;
		}

		public static void ClearThread()
		{
			saving = null;
		}

		public static void Reset()
		{
			prepared = null;
			saving = null;
			Snapshot result;
			while (completed.TryDequeue(out result))
			{
			}
		}

		public static void Tick()
		{
			Snapshot result;
			while (completed.TryPeek(out result))
			{
				if (result.Ledger.TryGetTarget(out var target) && target == Network.Host)
				{
					target.CompleteDrops(result.Ids);
					string[] ids = result.Ids;
					for (int i = 0; i < ids.Length; i++)
					{
						WorldObjects.RemoveDropMarker(ids[i]);
					}
				}
				completed.TryDequeue(out var _);
			}
		}
	}
	[HarmonyPatch(typeof(ZDOMan), "PrepareSave")]
	internal static class CaptureDropSave
	{
		private static void Postfix()
		{
			WorldDrops.Capture();
		}
	}
	[HarmonyPatch(typeof(ZNet), "SaveWorldThread")]
	internal static class WatchDropSave
	{
		private static void Prefix()
		{
			WorldDrops.Begin();
		}

		private static Exception Finalizer(Exception __exception)
		{
			WorldDrops.ClearThread();
			return __exception;
		}
	}
	[HarmonyPatch(typeof(SaveSystem), "EndSave")]
	internal static class ConfirmDropSave
	{
		private static void Postfix(bool __1)
		{
			WorldDrops.End(__1);
		}
	}
	internal sealed class Appearance
	{
		public string Id;

		public string OwnerName;

		[JsonIgnore]
		public long Revision;

		public Look Look;

		public Dictionary<string, Item> Equipment;

		public long OfferRevision;
	}
	internal static class WorldObjects
	{
		public const string Prefab = "PT_Trader";

		public static GameObject TraderPrefab;

		public static Sprite ScalesIcon;

		public static string[] Hairs = Array.Empty<string>();

		public static string[] Beards = Array.Empty<string>();

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

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

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

		private static readonly string[] Men = new string[6] { "Bjorn", "Eirik", "Torstein", "Ulf", "Harald", "Leif" };

		private static readonly string[] Women = new string[6] { "Sigrid", "Ingrid", "Astrid", "Freydis", "Helga", "Gudrun" };

		public static void Register()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			try
			{
				L.Select(Localization.instance);
				if (!Plugin.Headless && !Object.op_Implicit((Object)(object)ScalesIcon))
				{
					ScalesIcon = Icon();
				}
				TraderPrefab = BuildNpc("PT_Trader");
				PieceConfig val = new PieceConfig
				{
					Name = "$pt_S080",
					Description = "$pt_Recipe",
					PieceTable = "Hammer",
					Category = "$pt_S134",
					Icon = ScalesIcon,
					Requirements = ((IEnumerable<KeyValuePair<string, int>>)Plugin.Cost).Select((Func<KeyValuePair<string, int>, RequirementConfig>)((KeyValuePair<string, int> p) => new RequirementConfig(p.Key, p.Value, 0, false))).ToArray()
				};
				PieceManager.Instance.AddPiece(new CustomPiece(TraderPrefab, true, val));
				PrefabManager.OnVanillaPrefabsAvailable -= Register;
			}
			catch (Exception e)
			{
				Plugin.Error(e);
			}
		}

		private static GameObject BuildNpc(string name)
		{
			//IL_0141: 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)
			GameObject val = PrefabManager.Instance.CreateClonedPrefab(name, "Player");
			Check.That((Object)(object)val != (Object)null && !val.activeInHierarchy, "Could not safely prepare the player visual model");
			VisEquipment component = val.GetComponent<VisEquipment>();
			Check.That(Object.op_Implicit((Object)(object)component), "The player model has no VisEquipment");
			MonoBehaviour[] array = (from b in val.GetComponentsInChildren<MonoBehaviour>(true)
				where !(b is Player) && !(b is VisEquipment) && !(b is ZNetView)
				select b).ToArray();
			for (int num = 0; num < array.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)array[num]);
			}
			Player[] componentsInChildren = val.GetComponentsInChildren<Player>(true);
			for (int num = 0; num < componentsInChildren.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren[num]);
			}
			Rigidbody[] componentsInChildren2 = val.GetComponentsInChildren<Rigidbody>(true);
			for (int num = 0; num < componentsInChildren2.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren2[num]);
			}
			Collider[] componentsInChildren3 = val.GetComponentsInChildren<Collider>(true);
			for (int num = 0; num < componentsInChildren3.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren3[num]);
			}
			AudioSource[] componentsInChildren4 = val.GetComponentsInChildren<AudioSource>(true);
			for (int num = 0; num < componentsInChildren4.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren4[num]);
			}
			component.m_playerComponent = null;
			component.m_isPlayer = true;
			component.m_randomModelIndex = false;
			component.m_clothColliders.Clear();
			ZNetView component2 = val.GetComponent<ZNetView>();
			component2.m_persistent = true;
			component2.m_type = (ObjectType)2;
			component2.m_distant = false;
			val.layer = LayerMask.NameToLayer("piece");
			CapsuleCollider obj = val.AddComponent<CapsuleCollider>();
			obj.center = new Vector3(0f, 1f, 0f);
			obj.height = 2f;
			obj.radius = 0.35f;
			Piece obj2 = val.AddComponent<Piece>();
			obj2.m_canBeRemoved = true;
			obj2.m_canRotate = true;
			obj2.m_resources = Array.Empty<Requirement>();
			obj2.m_noInWater = true;
			obj2.m_clipGround = true;
			obj2.m_spaceRequirement = 0.4f;
			((StaticTarget)obj2).m_primaryTarget = false;
			((StaticTarget)obj2).m_randomTarget = false;
			obj2.m_targetNonPlayerBuilt = false;
			val.AddComponent<TraderNPC>();
			if (Plugin.Headless)
			{
				((Behaviour)component).enabled = false;
				Renderer[] componentsInChildren5 = val.GetComponentsInChildren<Renderer>(true);
				for (int num = 0; num < componentsInChildren5.Length; num++)
				{
					componentsInChildren5[num].enabled = false;
				}
				Animator[] componentsInChildren6 = val.GetComponentsInChildren<Animator>(true);
				for (int num = 0; num < componentsInChildren6.Length; num++)
				{
					((Behaviour)componentsInChildren6[num]).enabled = false;
				}
				Cloth[] componentsInChildren7 = val.GetComponentsInChildren<Cloth>(true);
				for (int num = 0; num < componentsInChildren7.Length; num++)
				{
					componentsInChildren7[num].enabled = false;
				}
			}
			return val;
		}

		public static void PopulateHair()
		{
			if (!((Object)(object)ObjectDB.instance == (Object)null))
			{
				allHairs = (from i in ObjectDB.instance.GetAllItems((ItemType)10, "Hair")
					select ((Object)((Component)i).gameObject).name into n
					orderby n
					select n).ToArray();
				Hairs = HairstyleChoices.Current(allHairs);
				Beards = (from i in ObjectDB.instance.GetAllItems((ItemType)10, "Beard")
					select ((Object)((Component)i).gameObject).name into n
					orderby n
					select n).ToArray();
			}
		}

		public static void SetBuildCost(Dictionary<string, int> cost)
		{
			if (Object.op_Implicit((Object)(object)TraderPrefab) && Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				Requirement[] resources = ((IEnumerable<KeyValuePair<string, int>>)cost).Select((Func<KeyValuePair<string, int>, Requirement>)delegate(KeyValuePair<string, int> p)
				{
					//IL_0040: Unknown result type (might be due to invalid IL or missing references)
					//IL_0045: Unknown result type (might be due to invalid IL or missing references)
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0059: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Expected O, but got Unknown
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(p.Key);
					ItemDrop val = (Object.op_Implicit((Object)(object)itemPrefab) ? itemPrefab.GetComponent<ItemDrop>() : null);
					Check.That(Object.op_Implicit((Object)(object)val), "Building resource not found: " + p.Key);
					return new Requirement
					{
						m_resItem = val,
						m_amount = p.Value,
						m_recover = false
					};
				}).ToArray();
				Piece component = TraderPrefab.GetComponent<Piece>();
				component.m_resources = resources;
				component.m_description = "$pt_Recipe";
			}
		}

		public static void ReleaseAssets()
		{
			Reset();
			if (Object.op_Implicit((Object)(object)ScalesIcon))
			{
				Texture2D texture = ScalesIcon.texture;
				Object.Destroy((Object)(object)ScalesIcon);
				if (Object.op_Implicit((Object)(object)texture))
				{
					Object.Destroy((Object)(object)texture);
				}
			}
			ScalesIcon = null;
			Hairs = (Beards = (allHairs = Array.Empty<string>()));
		}

		public static Look RandomLook()
		{
			if (Hairs.Length == 0)
			{
				PopulateHair();
			}
			int num = Random.Range(0, 2);
			string[] array = ((num == 0) ? Men : Women);
			return new Look
			{
				Body = num,
				Name = L.Text(array[Random.Range(0, array.Length)]),
				Hair = ((Hairs.Length != 0) ? Hairs[Random.Range(0, Hairs.Length)] : ""),
				Beard = ((num == 0 && Beards.Length != 0) ? Beards[Random.Range(0, Beards.Length)] : "")
			};
		}

		public static void ValidateLook(Look look)
		{
			Check.That(look != null, "No appearance selected");
			look.Validate();
			if (Hairs.Length == 0)
			{
				PopulateHair();
			}
			Check.That((look.Hair == "" || allHairs.Contains(look.Hair)) && (look.Beard == "" || Beards.Contains(look.Beard)), "Unknown hairstyle or beard");
		}

		public static void Reset()
		{
			objects.Clear();
			orphans.Clear();
			TraderMap.Reset();
		}

		public static void Reconcile(Registry registry)
		{
			List<ZDO> list = new List<ZDO>();
			int num = 0;
			while (!ZDOMan.instance.GetAllZDOsWithPrefabIterative("PT_Trader", list, ref num))
			{
			}
			foreach (ZDO item in list)
			{
				string text = item.GetString("PT.id", "");
				Trader value;
				if (item.GetBool("PT.dropped", false))
				{
					Network.Host.CompleteDrops(new string[1] { text });
					item.SetOwner(ZNet.GetUID());
					ZDOMan.instance.DestroyZDO(item);
				}
				else if (registry.Drops.ContainsKey(text))
				{
					objects[text] = item;
				}
				else if (!registry.Traders.TryGetValue(text, out value))
				{
					Plugin.Warn("Trader without registry data left in the world: " + text + ". Other traders remain available.");
					if (!string.IsNullOrEmpty(text))
					{
						orphans[text] = item;
					}
				}
				else if (value.Place != PlaceState.Placed || objects.ContainsKey(text))
				{
					ZDOMan.instance.DestroyZDO(item);
				}
				else
				{
					objects[text] = item;
				}
			}
			foreach (Trader value2 in registry.Traders.Values)
			{
				Apply(value2);
			}
			DropPlan[] array = Network.Host.Data.Drops.Values.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				ApplyDrops(array[i]);
			}
		}

		public static bool RemoveOrphan(string id, Vector3 playerPosition, out Vector3 removedPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			removedPosition = Vector3.zero;
			if (!orphans.TryGetValue(id, out var value))
			{
				return false;
			}
			Check.That(Vector3.Distance(playerPosition, value.GetPosition()) <= 5f, "Too far from the trader");
			Check.That(!Network.Host.Data.Traders.ContainsKey(id) && !Network.Host.Data.Drops.ContainsKey(id), "Data changed: open the trader again");
			removedPosition = value.GetPosition();
			value.SetOwner(ZNet.GetUID());
			ZDOMan.instance.DestroyZDO(value);
			orphans.Remove(id);
			return true;
		}

		public static void HammerEffects(float[] position, float yaw, bool removed)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (Object.op_Implicit((Object)(object)localPlayer) && Object.op_Implicit((Object)(object)ZNetScene.instance))
				{
					Vector3 val = Network.Vec(position);
					GameObject prefab = ZNetScene.instance.GetPrefab("wood_floor");
					Piece val2 = (Object.op_Implicit((Object)(object)prefab) ? prefab.GetComponent<Piece>() : null);
					if (Object.op_Implicit((Object)(object)val2))
					{
						val2.m_placeEffect.Create(val, Quaternion.Euler(0f, yaw, 0f), (Transform)null, 1f, -1, ((Character)localPlayer).GetZDOID());
					}
					if (removed)
					{
						localPlayer.m_removeEffects.Create(val, Quaternion.identity, (Transform)null, 1f, -1, ((Character)localPlayer).GetZDOID());
					}
				}
			}
			catch (Exception e)
			{
				Plugin.Error(e);
			}
		}

		public static bool DropDelivered(string id)
		{
			if (objects.TryGetValue(id, out var value))
			{
				return value.GetBool("PT.dropped", false);
			}
			return false;
		}

		public static void RemoveDropMarker(string id)
		{
			if (DropDelivered(id))
			{
				ZDO val = objects[id];
				val.SetOwner(ZNet.GetUID());
				ZDOMan.instance.DestroyZDO(val);
				objects.Remove(id);
			}
		}

		public static void ValidateDrops(DropPlan plan)
		{
			plan.Validate();
			foreach (Item item in plan.Items.Concat(new Item[1] { Items.Factory("Coins") }))
			{
				Check.That(Object.op_Implicit((Object)(object)Items.Decode(item).m_dropPrefab.GetComponent<ZNetView>()), "The item has no network component: " + item.Prefab);
			}
		}

		public static void ApplyDrops(DropPlan plan)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			if (DropDelivered(plan.Id))
			{
				return;
			}
			ValidateDrops(plan);
			if (!objects.TryGetValue(plan.Id, out var value))
			{
				value = ZDOMan.instance.CreateNewZDO(Network.Vec(plan.Position), StringExtensionMethods.GetStableHashCode("PT_Trader"));
				value.Persistent = true;
				value.SetPrefab(StringExtensionMethods.GetStableHashCode("PT_Trader"));
				value.Set("PT.id", plan.Id);
				objects[plan.Id] = value;
			}
			value.SetOwner(ZNet.GetUID());
			List<ZDO> list = new List<ZDO>();
			try
			{
				int num = 0;
				foreach (Item item in plan.Contents(Items.Factory("Coins")))
				{
					ItemData obj = Items.Decode(item);
					ZNetView component = obj.m_dropPrefab.GetComponent<ZNetView>();
					Check.That(Object.op_Implicit((Object)(object)component), "The item has no network component: " + item.Prefab);
					float num2 = (float)num++ * 2.399963f;
					Vector3 val = Network.Vec(plan.Position) + new Vector3(Mathf.Cos(num2) * 0.5f, 0.7f + (float)(num % 4) * 0.1f, Mathf.Sin(num2) * 0.5f);
					ZDO val2 = ZDOMan.instance.CreateNewZDO(val, StringExtensionMethods.GetStableHashCode(item.Prefab));
					list.Add(val2);
					val2.SetOwner(ZNet.GetUID());
					val2.Persistent = true;
					val2.Type = component.m_type;
					val2.SetPrefab(StringExtensionMethods.GetStableHashCode(item.Prefab));
					val2.SetRotation(Quaternion.identity);
					ItemDrop.SaveToZDO(obj, val2, -1);
				}
				value.Set("PT.dropped", true);
			}
			catch
			{
				foreach (ZDO item2 in list)
				{
					item2.SetOwner(ZNet.GetUID());
					ZDOMan.instance.DestroyZDO(item2);
				}
				throw;
			}
			TraderNPC traderNPC = TraderNPC.Find(plan.Id);
			if (Object.op_Implicit((Object)(object)traderNPC))
			{
				traderNPC.Sync();
			}
		}

		public static void Apply(Trader trader)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (trader.Place != PlaceState.Placed)
			{
				if (objects.TryGetValue(trader.Id, out var value))
				{
					value.SetOwner(ZNet.GetUID());
					ZDOMan.instance.DestroyZDO(value);
					objects.Remove(trader.Id);
				}
				return;
			}
			if (!objects.TryGetValue(trader.Id, out var value2))
			{
				value2 = ZDOMan.instance.CreateNewZDO(Network.Vec(trader.Position), StringExtensionMethods.GetStableHashCode("PT_Trader"));
				value2.Persistent = true;
				value2.Type = (ObjectType)2;
				value2.SetPrefab(StringExtensionMethods.GetStableHashCode("PT_Trader"));
				objects[trader.Id] = value2;
			}
			value2.SetOwner(ZNet.GetUID());
			value2.SetPosition(Network.Vec(trader.Position));
			value2.SetRotation(Quaternion.Euler(0f, trader.Yaw, 0f));
			TraderAppearance.Write(value2, trader.Look, trader.Equipment);
			value2.Set("PT.id", trader.Id);
			value2.Set("PT.revision", trader.Revision);
			value2.Set("PT.appearance", Json.Write(new Appearance
			{
				Id = trader.Id,
				OwnerName = trader.OwnerName,
				OfferRevision = OfferNews.Version(trader),
				Look = trader.Look,
				Equipment = trader.Equipment.ToDictionary((KeyValuePair<string, Item> p) => p.Key, (KeyValuePair<string, Item> p) => new Item
				{
					Prefab = p.Value.Prefab,
					Quality = p.Value.Quality,
					Variant = p.Value.Variant
				})
			}));
			TraderNPC traderNPC = TraderNPC.Find(trader.Id);
			if (Object.op_Implicit((Object)(object)traderNPC))
			{
				traderNPC.Sync();
			}
		}

		public static Sprite Icon()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = NativeWidgets.LoadTexture("merchant-icon.png");
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}
	}
	public sealed class TraderNPC : MonoBehaviour, Hoverable, Interactable
	{
		private static readonly HashSet<TraderNPC> active = new HashSet<TraderNPC>();

		public string Id = "";

		public long Revision;

		internal Appearance Current;

		private ZNetView view;

		private VisEquipment visual;

		private long revision = -1L;

		private Animator animator;

		private readonly HashSet<int> triggers = new HashSet<int>();

		private readonly GreetingGate greeting = new GreetingGate();

		private readonly HashSet<int> presentPlayers = new HashSet<int>();

		private float nextGesture;

		private bool wavePending;

		private TraderOfferMarker offerMarker;

		private void Awake()
		{
			view = ((Component)this).GetComponent<ZNetView>();
			visual = ((Component)this).GetComponent<VisEquipment>();
		}

		private void Start()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Invalid comparison between Unknown and I4
			if (Plugin.Headless)
			{
				((Behaviour)this).enabled = false;
				return;
			}
			animator = ((Component)this).GetComponentInChildren<Animator>();
			TraderPose.Stand(animator);
			if (!Object.op_Implicit((Object)(object)view) || !view.IsValid())
			{
				return;
			}
			active.Add(this);
			offerMarker = ((Component)this).gameObject.AddComponent<TraderOfferMarker>();
			if (Object.op_Implicit((Object)(object)animator))
			{
				animator.fireEvents = false;
				AnimatorControllerParameter[] parameters = animator.parameters;
				foreach (AnimatorControllerParameter val in parameters)
				{
					if ((int)val.type == 9)
					{
						triggers.Add(val.nameHash);
					}
				}
			}
			Sync();
			((MonoBehaviour)this).InvokeRepeating("Refresh", 1f, 1f);
		}

		private void Refresh()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			Sync();
			if (!Object.op_Implicit((Object)(object)view) || !view.IsValid() || Current == null || !((Component)this).gameObject.activeInHierarchy)
			{
				return;
			}
			offerMarker?.Refresh(Current);
			TraderMap.Observe(view.GetZDO(), Current.Look.Name);
			presentPlayers.Clear();
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (Object.op_Implicit((Object)(object)allPlayer) && !((Character)allPlayer).IsDead())
				{
					int instanceID = ((Object)allPlayer).GetInstanceID();
					presentPlayers.Add(instanceID);
					if (greeting.Enter(instanceID, Vector3.Distance(((Component)allPlayer).transform.position, ((Component)this).transform.position)))
					{
						wavePending = true;
					}
				}
			}
			greeting.Prune(presentPlayers);
			if (!greeting.HasNearby)
			{
				wavePending = false;
			}
			if (wavePending && Time.unscaledTime >= nextGesture)
			{
				wavePending = false;
				Gesture("wave");
			}
		}

		private void Gesture(string name, bool interrupt = false)
		{
			if (!Object.op_Implicit((Object)(object)animator) || (!interrupt && Time.unscaledTime < nextGesture))
			{
				return;
			}
			int num = Animator.StringToHash("emote_" + name);
			if (triggers.Contains(num))
			{
				int num2 = Animator.StringToHash("emote_stop");
				if (triggers.Contains(num2))
				{
					animator.ResetTrigger(num2);
				}
				animator.SetTrigger(num);
				nextGesture = Time.unscaledTime + 4f;
			}
		}

		internal void Farewell(string gesture)
		{
			wavePending = false;
			Gesture(gesture, interrupt: true);
		}

		private void OnDestroy()
		{
			active.Remove(this);
			((MonoBehaviour)this).CancelInvoke();
		}

		public static TraderNPC Find(string id)
		{
			return active.FirstOrDefault((TraderNPC n) => Object.op_Implicit((Object)(object)n) && n.Id == id);
		}

		public void Sync()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)view) || !view.IsValid())
			{
				return;
			}
			ZDO zDO = view.GetZDO();
			if (zDO.GetBool("PT.dropped", false))
			{
				TraderMap.Remove(zDO.m_uid);
				((Component)this).gameObject.SetActive(false);
				return;
			}
			long num = zDO.GetLong("PT.revision", -1L);
			if (num == revision)
			{
				return;
			}
			string text = zDO.GetString("PT.appearance", "");
			if (text.Length == 0 || text.Length > 262144)
			{
				return;
			}
			try
			{
				Appearance appearance = Json.Read<Appearance>(text);
				Id = appearance.Id;
				Revision = num;
				appearance.Revision = num;
				Current = appearance;
				ApplyLook(appearance);
				revision = num;
				TraderMap.Observe(zDO, appearance.Look.Name);
			}
			catch (Exception e)
			{
				Plugin.Error(e);
				((MonoBehaviour)this).CancelInvoke();
			}
		}

		internal void ApplyLook(Appearance a)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)visual))
			{
				visual = ((Component)this).GetComponent<VisEquipment>();
			}
			if (Object.op_Implicit((Object)(object)visual))
			{
				visual.SetModel(a.Look.Body);
				visual.SetSkinColor(Network.Vec(a.Look.Skin));
				visual.SetHairColor(Network.Vec(a.Look.HairColor));
				visual.SetHairItem((!string.IsNullOrEmpty(a.Look.Hair)) ? StringExtensionMethods.GetStableHashCode(a.Look.Hair) : 0);
				visual.SetBeardItem((!string.IsNullOrEmpty(a.Look.Beard)) ? StringExtensionMethods.GetStableHashCode(a.Look.Beard) : 0);
				visual.SetHelmetItem(Hash("Голова"));
				visual.SetChestItem(Hash("Торс"));
				visual.SetLegItem(Hash("Ноги"));
				visual.SetUtilityItem(Hash("Аксессуар"));
				Item value;
				Item item = ((a.Equipment != null && a.Equipment.TryGetValue("Плечи", out value)) ? value : null);
				visual.SetShoulderItem(Hash("Плечи"), item?.Variant ?? 0, item?.Quality ?? 1);
				Animator componentInChildren = ((Component)this).GetComponentInChildren<Animator>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.applyRootMotion = false;
					componentInChildren.SetFloat("forward_speed", 0f);
					componentInChildren.SetFloat("sideway_speed", 0f);
				}
			}
			int Hash(string slot)
			{
				if (a.Equipment == null || !a.Equipment.TryGetValue(slot, out var value2))
				{
					return 0;
				}
				return StringExtensionMethods.GetStableHashCode(value2.Prefab);
			}
		}

		public string GetHoverName()
		{
			return Current?.Look.Name ?? L.Text("Trader");
		}

		public float GetHoverOffset()
		{
			return 1.5f;
		}

		public string GetHoverText()
		{
			return GetHoverName() + L.Text("\nOwner: ") + (Current?.OwnerName ?? "…") + "\n" + Localization.instance.Localize(L.Text("[<color=yellow><b>$KEY_Use</b></color>] Open trader"));
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			if (hold || Id.Length == 0)
			{
				return false;
			}
			Network.Open(Id);
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "TryPlacePiece")]
	internal static class PlaceTrader
	{
		private static bool Prefix(Player __instance, Piece piece, ref bool __result)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)((Component)piece).GetComponent<TraderNPC>()))
			{
				return true;
			}
			__result = false;
			try
			{
				Check.That(!Network.Busy, "Wait for the operation to finish");
				AccessTools.Method(typeof(Player), "UpdatePlacementGhost", (Type[])null, (Type[])null).Invoke(__instance, new object[1] { true });
				Check.That(AccessTools.Field(typeof(Player), "m_placementStatus").GetValue(__instance).ToString() == "Valid", "Cannot place a trader here");
				GameObject val = (GameObject)AccessTools.Field(typeof(Player), "m_placementGhost").GetValue(__instance);
				Check.That(Object.op_Implicit((Object)(object)val) && Vector3.Distance(val.transform.position, ((Component)__instance).transform.position) <= 5f, "Too far away to build");
				Vector3 position = val.transform.position;
				Request request = new Request();
				request.Action = "create";
				request.Position = new float[3] { position.x, position.y, position.z };
				request.Yaw = val.transform.eulerAngles.y;
				Network.Operate(request);
			}
			catch (Exception e)
			{
				Network.Fail(e);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "RemovePiece")]
	internal static class DismantleTrader
	{
		private static bool Prefix(Player __instance, ref bool __result)
		{
			Piece hoveringPiece = __instance.GetHoveringPiece();
			TraderNPC traderNPC = (Object.op_Implicit((Object)(object)hoveringPiece) ? ((Component)hoveringPiece).GetComponent<TraderNPC>() : null);
			if (!Object.op_Implicit((Object)(object)traderNPC))
			{
				return true;
			}
			__result = false;
			if (!Network.Busy)
			{
				Network.Send(new Request
				{
					Action = "dismantle",
					Trader = traderNPC.Id,
					Revision = traderNPC.Revision
				});
			}
			return false;
		}
	}
	internal static class L
	{
		private static TranslationCatalog catalog;

		private static string directory;

		private static string language;

		private static readonly MethodInfo addWord = AccessTools.Method(typeof(Localization), "AddWord", (Type[])null, (Type[])null);

		internal static void Initialize()
		{
			directory = Path.GetDirectoryName(typeof(L).Assembly.Location);
			using Stream stream = typeof(L).Assembly.GetManifestResourceStream("PlayerTraders.Localization.catalog.json");
			using StreamReader streamReader = new StreamReader(stream);
			catalog = new TranslationCatalog(streamReader.ReadToEnd());
			try
			{
				TranslationCatalog.WriteTemplateIfMissing(Path.Combine(directory, "english_PlayerTraders.json"), catalog.EnglishTemplate());
			}
			catch (Exception ex)
			{
				Plugin.Warn("Could not create the English translation template: " + ex.Message);
			}
		}

		internal static void Select(Localization localization, string selected = null)
		{
			if (catalog != null && localization != null)
			{
				selected = selected ?? localization.GetSelectedLanguage();
				if (language != selected)
				{
					language = selected;
					string json = TranslationFiles.Read(directory, Paths.PluginPath, selected, Plugin.Warn);
					catalog.Load(json, Plugin.Warn);
				}
				string[] array = new string[3] { "S080", "Recipe", "S134" };
				foreach (string text in array)
				{
					addWord.Invoke(localization, new object[2]
					{
						"pt_" + text,
						catalog.ByKey(text)
					});
				}
			}
		}

		internal static string Text(string source)
		{
			return catalog?.Text(source) ?? source;
		}

		internal static string Message(string source)
		{
			return catalog?.Message(source) ?? source;
		}

		internal static string Format(string source, params object[] args)
		{
			return string.Format(CultureInfo.CurrentCulture, Text(source), args);
		}

		internal static void Reset()
		{
			catalog = null;
			directory = (language = null);
		}
	}
	[HarmonyPatch(typeof(Localization), "SetupLanguage")]
	internal static class TraderLanguage
	{
		private static void Postfix(Localization __instance, string __0)
		{
			L.Select(__instance, __0);
		}
	}
	[BepInPlugin("ru.playertraders", "Player Traders", "0.6.5")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Id = "ru.playertraders";

		public const string ModVersion = "0.6.5";

		public static Plugin Instance;

		public static ConfigEntry<string> ConstructionCost;

		internal static Dictionary<string, int> Cost = BuildCost.Parse("Coins:50");

		public static ConfigEntry<bool> Diagnostics;

		private Harmony patches;

		internal static bool Headless
		{
			get
			{
				if (!GUIManager.IsHeadless())
				{
					if (Object.op_Implicit((Object)(object)ZNet.instance))
					{
						return ZNet.instance.IsDedicated();
					}
					return false;
				}
				return true;
			}
		}

		private void Awake()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			Instance = this;
			L.Initialize();
			patches = new Harmony("ru.playertraders");
			patches.PatchAll();
			PrefabManager.OnVanillaPrefabsAvailable += WorldObjects.Register;
			ItemManager.OnItemsRegistered += WorldObjects.PopulateHair;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Player Traders: loading 0.6.5");
		}

		internal static void LoadServerConfiguration()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			Check.That(Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer(), "Only the server can load trader settings");
			ConfigFile val = new ConfigFile(Path.Combine(Paths.ConfigPath, "PlayerTraders.config"), true);
			ConstructionCost = val.Bind<string>("Construction", "Resources", "Coins:50", "Construction cost as Prefab:Amount pairs, separated by commas; up to 6 resources. Default: Coins:50 (50 coins). Restart the game/server after changing this setting.");
			Cost = BuildCost.Parse(ConstructionCost.Value);
			Diagnostics = val.Bind<bool>("Diagnostics", "VerboseLog", false, "Detailed operation messages");
			WorldObjects.SetBuildCost(Cost);
			LogInfo("Server trader recipe: " + ConstructionCost.Value + "; config: " + val.ConfigFilePath);
		}

		internal static void ResetConfiguration()
		{
			Cost = BuildCost.Parse("Coins:50");
			Diagnostics = null;
			ConstructionCost = null;
			if (Object.op_Implicit((Object)(object)WorldObjects.TraderPrefab) && Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				WorldObjects.SetBuildCost(Cost);
			}
		}

		public static void Error(Exception e)
		{
			((BaseUnityPlugin)Instance).Logger.LogError((object)e);
		}

		public static void LogInfo(string value)
		{
			((BaseUnityPlugin)Instance).Logger.LogInfo((object)value);
		}

		public static void Warn(string value)
		{
			((BaseUnityPlugin)Instance).Logger.LogWarning((object)value);
		}

		public static void Trace(string value)
		{
			ConfigEntry<bool> diagnostics = Diagnostics;
			if (diagnostics != null && diagnostics.Value)
			{
				((BaseUnityPlugin)Instance).Logger.LogInfo((object)value);
			}
		}

		private void Update()
		{
			Network.Tick();
			if (!Headless)
			{
				TraderUI.Update();
			}
		}

		private void OnDestroy()
		{
			TraderUI.Close(send: false);
			TraderUI.ReleaseInput();
			TraderOfferMarker.ReleaseAssets();
			NativeWidgets.ReleaseAssets();
			Network.Reset();
			WorldObjects.ReleaseAssets();
			PrefabManager.OnVanillaPrefabsAvailable -= WorldObjects.Register;
			ItemManager.OnItemsRegistered -= WorldObjects.PopulateHair;
			Harmony obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			L.Reset();
			Instance = null;
		}
	}
	public static class Texts
	{
		public const string InvalidPacket = "Could not read trader network data. Please try again.";

		public const string Connecting = "The trader is still loading. Please try again in a moment.";

		public const string Aborted = "You moved away from the trader. The operation was cancelled; your items are unchanged.";

		public const string S001 = "Empty data";

		public const string S002 = "Enter a positive whole number";

		public const string S003 = "The number must be greater than zero";

		public const string S004 = "The name must contain 1 to 32 characters";

		public const string S005 = "Invalid item data";

		public const string S006 = "Invalid inventory";

		public const string S007 = "Duplicate inventory slot";

		public const string S008 = "The item has already been moved";

		public const string S009 = "Unequip the item first";

		public const string S010 = "Not enough items";

		public const string S011 = "Not enough space";

		public const string S012 = "Out of stock";

		public const string S013 = "Not enough coins";

		public const string S014 = "Bjorn";

		public const string S015 = "Unknown body type";

		public const string S016 = "Invalid colour";

		public const string S017 = "Invalid appearance";

		public const string S018 = "Invalid trader data";

		public const string S019 = "The warehouse must have 100 slots";

		public const string S021 = "Data size limit exceeded";

		public const string S022 = "Invalid equipment";

		public const string S023 = "Invalid price";

		public const string S024 = "Unsupported format or different world";

		public const string S025 = "Invalid ID";

		public const string S026 = "Corrupted journal";

		public const string S027 = "Unknown transaction stage";

		public const string S028 = "The character receipt does not match the host journal";

		public const string S029 = "Inventory does not match the journal; duplicate delivery blocked. Saved data needs checking.";

		public const string S030 = "Голова";

		public const string S031 = "Торс";

		public const string S032 = "Ноги";

		public const string S033 = "Плечи";

		public const string S034 = "Аксессуар";

		public const string S035 = "Invalid transaction number";

		public const string S036 = "The previous transaction needs recovery";

		public const string S037 = "Duplicate or outdated transaction";

		public const string S038 = "Inventory confirmation missing";

		public const string S039 = "Trader not found";

		public const string S040 = "The trader has an unfinished transaction";

		public const string S041 = "Data changed: open the trader again";

		public const string S042 = "Only the owner can do this";

		public const string S043 = "The trader is not placed in the world";

		public const string S045 = "The unit price must be a positive whole number";

		public const string S047 = "This item is no longer for sale";

		public const string S048 = "Choose an item quantity";

		public const string S049 = "The total is too large; choose a smaller quantity";

		public const string S050 = "Not enough coins in the till";

		public const string S051 = "Appearance is not set";

		public const string S052 = "Only head, chest, legs, shoulders and accessory slots are supported";

		public const string S053 = "The slot is empty";

		public const string S055 = "Unknown action";

		public const string S056 = "Choose where to return the clothing";

		public const string S057 = "Not enough materials to create a trader";

		public const string S058 = "The trader is busy";

		public const string S059 = "Close the other trader first";

		public const string S060 = "Session ended: open the trader again";

		public const string S061 = "The data file is too large";

		public const string S062 = "Corrupted data; the original is preserved and operations are blocked";

		public const string S063 = "Storage is full: operations stopped";

		public const string S064 = "The main file is missing, but a backup or pending file exists: recovery required";

		public const string S065 = "An operation is already in progress";

		public const string S066 = "Transaction not found";

		public const string S067 = "Receipt not found";

		public const string S068 = "Transaction not confirmed";

		public const string S069 = "A confirmed transaction cannot be cancelled";

		public const string S070 = "The game blocked character saving; the transaction remains in the journal";

		public const string S071 = "Could not save the character: the transaction is awaiting recovery";

		public const string S072 = "Unknown item: ";

		public const string S073 = "Game item missing: ";

		public const string S074 = "Item properties do not match the game";

		public const string S075 = "Inventory changed during the transaction; recovery required";

		public const string S076 = "Inventory size changed";

		public const string S077 = "Player equipment changed";

		public const string S078 = "Cannot remove an item the player is wearing";

		public const string S080 = "Trader";

		public const string S086 = "Invalid platform ID";

		public const string S087 = "The network message is too large";

		public const string S088 = "Too much custom item data";

		public const string S089 = "Connection lost";

		public const string S090 = "World ID is unavailable";

		public const string S091 = "Trader storage is locked: ";

		public const string S092 = "Connection lost or trader too far away";

		public const string S093 = "Player unavailable";

		public const string S094 = "Connection not confirmed";

		public const string S095 = "Connection owner is unavailable";

		public const string S096 = "Character unavailable";

		public const string S097 = "Invalid position";

		public const string S098 = "The world is still loading";

		public const string S099 = "Invalid request";

		public const string S100 = "Too many requests";

		public const string S101 = "Too far away to build";

		public const string S102 = "Building is not allowed here";

		public const string S103 = "Invalid placement";

		public const string S105 = "Too far from the trader";

		public const string S107 = "Operation failed. Check the log; no duplicate items were delivered.";

		public const string S108 = "Recover the unfinished transaction first";

		public const string S109 = "Wait for the connection or transaction recovery";

		public const string S110 = "The journal belongs to another world";

		public const string S111 = "Client journal missing; a backup was found";

		public const string S112 = "The world or connection changed";

		public const string S113 = "Inventory changed before confirmation. Transaction blocked for inspection.";

		public const string S114 = "The host does not recognise the recorded transaction: a save rollback may have occurred. Automatic recovery blocked.";

		public const string S115 = "Session";

		public const string S116 = "Recovery blocked; see the log";

		public const string S117 = "Another transaction is awaiting recovery";

		public const string S118 = "Transaction receipt mismatch";

		public const string S119 = "Character receipt missing; recovery required";

		public const string S120 = "Done";

		public const string S121 = "Error: ";

		public const string S122 = "Eirik";

		public const string S123 = "Torstein";

		public const string S124 = "Ulf";

		public const string S125 = "Harald";

		public const string S126 = "Leif";

		public const string S127 = "Sigrid";

		public const string S128 = "Ingrid";

		public const string S129 = "Astrid";

		public const string S130 = "Freydis";

		public const string S131 = "Helga";

		public const string S132 = "Gudrun";

		public const string S139 = "Could not safely prepare the player visual model";

		public const string S140 = "The player model has no VisEquipment";

		public const string S141 = "No appearance selected";

		public const string S142 = "Unknown hairstyle or beard";

		public const string S144 = "\nOwner: ";

		public const string S145 = "[<color=yellow><b>$KEY_Use</b></color>] Open trader";

		public const string S146 = "Wait for the operation to finish";

		public const string S147 = "Cannot place a trader here";

		public const string S170 = "Could not display item data";
	}
	public sealed class CurrencyGlyph : BaseMeshEffect
	{
		private Image icon;

		private bool before;

		private float heightRatio;

		private bool pending;

		private bool show;

		private Vector2 position;

		private Vector2 size;

		public static Image Attach(Text label, bool before = false, float heightRatio = 0.85f)
		{
			CurrencyGlyph currencyGlyph = ((Component)label).gameObject.AddComponent<CurrencyGlyph>();
			currencyGlyph.before = before;
			currencyGlyph.heightRatio = heightRatio;
			currencyGlyph.icon = NativeWidgets.Icon(((Component)label).transform, TraderSkinAssets.Get("coins"), 0f, 0f, 1f);
			currencyGlyph.icon.preserveAspect = false;
			((Behaviour)currencyGlyph.icon).enabled = false;
			((Graphic)label).SetVerticesDirty();
			return currencyGlyph.icon;
		}

		public override void ModifyMesh(VertexHelper mesh)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			if (!((UIBehaviour)this).IsActive() || !Object.op_Implicit((Object)(object)icon) || !Object.op_Implicit((Object)(object)icon.sprite))
			{
				return;
			}
			Text val = (Text)((BaseMeshEffect)this).graphic;
			IList<UIVertex> verts = val.cachedTextGenerator.verts;
			pending = true;
			show = false;
			if (verts.Count < 4)
			{
				return;
			}
			float num = 1f / val.pixelsPerUnit;
			Vector2 val2 = Vector2.op_Implicit(verts[0].position) * num;
			Vector2 val3 = ((Graphic)val).PixelAdjustPoint(val2) - val2;
			float num2 = float.MaxValue;
			float num3 = float.MinValue;
			float num4 = float.MaxValue;
			float num5 = float.MinValue;
			for (int i = 0; i + 3 < verts.Count; i += 4)
			{
				float num6 = float.MaxValue;
				float num7 = float.MinValue;
				float num8 = float.MaxValue;
				float num9 = float.MinValue;
				for (int j = 0; j < 4; j++)
				{
					Vector2 val4 = Vector2.op_Implicit(verts[i + j].position) * num + val3;
					num6 = Mathf.Min(num6, val4.x);
					num7 = Mathf.Max(num7, val4.x);
					num8 = Mathf.Min(num8, val4.y);
					num9 = Mathf.Max(num9, val4.y);
				}
				if (!(num9 <= num8) && !(num7 <= num6))
				{
					num2 = Mathf.Min(num2, num6);
					num3 = Mathf.Max(num3, num7);
					if (before)
					{
						num4 = Mathf.Min(num4, num8);
						num5 = Mathf.Max(num5, num9);
					}
					else
					{
						num4 = num8;
						num5 = num9;
					}
				}
			}
			float num10 = (num5 - num4) * heightRatio;
			if (!(num10 <= 0f) && !float.IsInfinity(num10))
			{
				show = true;
				Rect rect = icon.sprite.rect;
				float num11 = num10 * ((Rect)(ref rect)).width;
				rect = icon.sprite.rect;
				float num12 = num11 / ((Rect)(ref rect)).height;
				float num13 = Mathf.Max(2f, (float)val.fontSize * 0.14f);
				size = new Vector2(num12, num10);
				position = new Vector2(before ? (num2 - num13 - num12) : (num3 + num13), num4);
			}
		}

		private void LateUpdate()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (pending && Object.op_Implicit((Object)(object)icon))
			{
				pending = false;
				((Behaviour)icon).enabled = show;
				if (show)
				{
					RectTransform rectTransform = ((Graphic)icon).rectTransform;
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(0f, 1f);
					rectTransform.anchorMax = val;
					rectTransform.anchorMin = val;
					rectTransform.pivot = new Vector2(0f, 0f);
					rectTransform.sizeDelta = size;
					rectTransform.anchoredPosition = position;
				}
			}
		}
	}
	internal static class NativeWidgets
	{
		private static Texture2D panelTexture;

		private static readonly Vector2 TopLeft = new Vector2(0f, 1f);

		public static RectTransform Rect(Transform parent, string name, float x, float y, float w, float h)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Place(component, x, y, w, h);
			return component;
		}

		public static void Place(RectTransform r, float x, float y, float w, float h)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = (r.pivot = TopLeft);
			Vector2 anchorMin = (r.anchorMax = val);
			r.anchorMin = anchorMin;
			r.anchoredPosition = new Vector2(x, 0f - y);
			r.sizeDelta = new Vector2(w, h);
		}

		public static GameObject Panel(Transform parent, float x, float y, float w, float h)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)panelTexture))
			{
				panelTexture = LoadTexture("trader-panel.png");
			}
			RectTransform obj = Rect(parent, "TraderWindow", x, y, w, h);
			Fill((Transform)(object)obj, 10f, 10f, w - 20f, h - 20f, new Color(0.055f, 0.033f, 0.02f, 1f));
			RawImage obj2 = ((Component)Rect((Transform)(object)obj, "Wood", 0f, 0f, w, h)).gameObject.AddComponent<RawImage>();
			obj2.texture = (Texture)(object)panelTexture;
			((Graphic)obj2).color = Color.white;
			return ((Component)obj).gameObject;
		}

		internal static Texture2D LoadTexture(string file)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			using Stream stream = typeof(NativeWidgets).Assembly.GetManifestResourceStream("PlayerTraders.Assets." + file);
			CheckPanel(stream != null);
			byte[] array = new byte[stream.Length];
			int num;
			for (int i = 0; i < array.Length; i += num)
			{
				num = stream.Read(array, i, array.Length - i);
				if (num == 0)
				{
					throw new EndOfStreamException();
				}
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true);
			try
			{
				CheckPanel(ImageConversion.LoadImage(val, array, true));
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)2;
				((Texture)val).anisoLevel = 1;
				return val;
			}
			catch
			{
				Object.Destroy((Object)(object)val);
				throw;
			}
		}

		private static void CheckPanel(bool ok)
		{
			if (!ok)
			{
				throw new InvalidOperationException("Interface texture not found");
			}
		}

		public static void ReleaseAssets()
		{
			if (Object.op_Implicit((Object)(object)panelTexture))
			{
				Object.Destroy((Object)(object)panelTexture);
			}
			panelTexture = null;
			TraderSkinAssets.Release();
		}

		public static Image Fill(Transform parent, float x, float y, float w, float h, Color color)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Image obj = ((Component)Rect(parent, "Surface", x, y, w, h)).gameObject.AddComponent<Image>();
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		public static Image Paint(Transform p, string sprite, float x, float y, float w, float h, bool sliced = true)
		{
			Image obj = ((Component)Rect(p, sprite, x, y, w, h)).gameObject.AddComponent<Image>();
			obj.sprite = TraderSkinAssets.Get(sprite);
			obj.type = (Type)(sliced ? 1 : 0);
			obj.pixelsPerUnitMultiplier = 4f;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		public static void Line(Transform p, float x, float y, float w, float h = 1f)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (w <= 1f && h > 1f)
			{
				Image obj = ((Component)Rect(p, "Divider", x - 1f, y, 2f, h)).gameObject.AddComponent<Image>();
				obj.sprite = TraderSkinAssets.Get("line");
				((Graphic)obj).raycastTarget = false;
				((Component)Paint(p, "diamond", x - 9f, y + 12f, 18f, 12f, sliced: false)).transform.localRotation = Quaternion.Euler(0f, 0f, 90f);
			}
			else
			{
				Paint(p, "line", x, y - 1f, w, 2f, sliced: false);
				Paint(p, "diamond", x + w / 2f - 13f, y - 8f, 26f, 17f, sliced: false);
			}
		}

		public static void Surface(Transform p, float x, float y, float w, float h)
		{
			Paint(p, "panel", x, y, w, h);
		}

		public static void Board(Transform p, float x, float y, float w, float h, bool raised = false)
		{
			Paint(p, "panel", x, y, w, h);
		}

		public static void Mark(Selectable control, bool selected)
		{
			TraderSkin component = ((Component)control).GetComponent<TraderSkin>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.Highlight(selected);
			}
		}

		private static void Skin(Selectable control, string kind = "button")
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			Graphic targetGraphic = control.targetGraphic;
			if (Object.op_Implicit((Object)(object)targetGraphic))
			{
				targetGraphic.color = Color.clear;
				targetGraphic.raycastTarget = true;
			}
			RectTransform val = Rect(((Component)control).transform, "PaintedSkin", 0f, 0f, 1f, 1f);
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			Vector2 offsetMin = (val.offsetMax = Vector2.zero);
			val.offsetMin = offsetMin;
			if (kind == "button" || kind == "input")
			{
				val.offsetMin = new Vector2(-10f, -10f);
				val.offsetMax = new Vector2(10f, 10f);
			}
			Image val2 = ((Component)val).gameObject.AddComponent<Image>();
			val2.type = (Type)(!(kind == "close"));
			val2.pixelsPerUnitMultiplier = 4f;
			((Graphic)val2).raycastTarget = false;
			((Transform)val).SetAsFirstSibling();
			control.targetGraphic = (Graphic)(object)val2;
			control.transition = (Transition)1;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = Color.white;
			((ColorBlock)(ref colors)).pressedColor = new Color(0.85f, 0.82f, 0.77f);
			((ColorBlock)(ref colors)).selectedColor = Color.white;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.46f, 0.46f, 0.46f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0f;
			control.colors = colors;
			((Component)control).gameObject.AddComponent<TraderSkin>().Initialize(control, val2, kind);
		}

		public static Button Tab(Transform p, string text, float x, float y, float w, float h, bool active, Action click)
		{
			Button obj = Button(p, text, x, y, w, h, click);
			Mark((Selectable)(object)obj, active);
			return obj;
		}

		public static Text Label(Transform parent, string value, float x, float y, float w, float h, int size = 18, bool heading = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			GameObject obj = GUIManager.Instance.CreateText(value, parent, TopLeft, TopLeft, Vector2.zero, heading ? GUIManager.Instance.NorseBold : GUIManager.Instance.AveriaSerif, size, heading ? new Color(1f, 0.68f, 0.24f) : new Color(0.91f, 0.79f, 0.56f), true, Color.black, w, h, false);
			Place((RectTransform)obj.transform, x, y, w, h);
			Text component = obj.GetComponent<Text>();
			((Graphic)component).raycastTarget = false;
			component.supportRichText = false;
			return component;
		}

		public static Button Button(Transform parent, string text, float x, float y, float w, float h, Action action)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateButton(text, parent, TopLeft, TopLeft, Vector2.zero, w, h);
			Place((RectTransform)obj.transform, x, y, w, h);
			Button component = obj.GetComponent<Button>();
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				if (!Network.Busy)
				{
					TraderUI.Safe(action);
				}
			});
			Skin((Selectable)(object)component, (text == "×") ? "close" : "button");
			Text componentInChildren = obj.GetComponentInChildren<Text>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.font = GUIManager.Instance.AveriaSerif;
				componentInChildren.fontSize = 19;
				if (text == "×")
				{
					componentInChildren.text = "";
				}
				if (text == L.Text("Delete"))
				{
					((Graphic)componentInChildren).color = new Color(0.94f, 0.28f, 0.17f);
				}
			}
			QuietFocus(obj, inventory: false);
			return component;
		}

		public static InputField Field(Transform parent, string value, float x, float y, float w, float h, bool number = false)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateInputField(parent, TopLeft, TopLeft, Vector2.zero, (ContentType)(number ? 2 : 0), "", 18, w, h);
			Place((RectTransform)obj.transform, x, y, w, h);
			InputField component = obj.GetComponent<InputField>();
			component.characterLimit = (number ? 10 : 32);
			component.textComponent.alignment = (TextAnchor)3;
			Skin((Selectable)(object)component, "input");
			RectTransform val = Rect(obj.transform, "EditingLayer", 0f, 0f, w, h);
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			Vector2 offsetMin = (val.offsetMax = Vector2.zero);
			val.offsetMin = offsetMin;
			if (Object.op_Implicit((Object)(object)component.placeholder))
			{
				((Component)component.placeholder).transform.SetParent((Transform)(object)val, false);
			}
			((Component)component.textComponent).transform.SetParent((Transform)(object)val, false);
			component.customCaretColor = true;
			component.caretColor = new Color(1f, 1f, 0.9f, 1f);
			component.caretWidth = 2;
			component.caretBlinkRate = 0.85f;
			component.selectionColor = new Color(0.92f, 0.95f, 1f, 0.48f);
			component.text = value;
			return component;
		}

		public static Slider Slider(Transform parent, float value, float x, float y, float w, Action<float> change)
		{
			//IL_002d: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = Rect(parent, "AppearanceSlider", x, y, w, 28f);
			((Graphic)((Component)obj).gameObject.AddComponent<Image>()).color = Color.clear;
			Slider val = ((Component)obj).gameObject.AddComponent<Slider>();
			Paint((Transform)(object)obj, "slider", 8f, 10f, w - 16f, 8f);
			RectTransform val2 = Rect((Transform)(object)Rect((Transform)(object)obj, "HandleTravel", 12f, 0f, w - 24f, 28f), "Handle", 0f, 0f, 26f, 26f);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			val2.pivot = val3;
			Vector2 anchorMin = (val2.anchorMax = val3);
			val2.anchorMin = anchorMin;
			val2.anchoredPosition = Vector2.zero;
			Image val5 = ((Component)val2).gameObject.AddComponent<Image>();
			val5.sprite = TraderSkinAssets.Get("knob");
			val5.preserveAspect = true;
			val.handleRect = val2;
			((Selectable)val).targetGraphic = (Graphic)(object)val5;
			val.direction = (Direction)0;
			val.minValue = 0f;
			val.maxValue = 1f;
			val.wholeNumbers = false;
			val.value = value;
			((UnityEvent<float>)(object)val.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
			{
				if (!Network.Busy)
				{
					TraderUI.Safe(delegate
					{
						change(v);
					});
				}
			});
			return val;
		}

		public static RectTransform Scroll(Transform parent, float x, float y, float w, float h, float contentHeight, out ScrollRect scroll)
		{
			//IL_008a: 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_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: 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_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = Rect(parent, "ScrollArea", x, y, w, h);
			scroll = ((Component)val).gameObject.AddComponent<ScrollRect>();
			scroll.scrollSensitivity = 100f;
			scroll.horizontal = false;
			scroll.vertical = true;
			scroll.movementType = (MovementType)2;
			scroll.inertia = false;
			RectTransform viewport = Rect((Transform)(object)val, "Viewport", 0f, 0f, w - 26f, h);
			((Graphic)((Component)viewport).gameObject.AddComponent<Image>()).color = Color.clear;
			((Component)viewport).gameObject.AddComponent<RectMask2D>();
			RectTransform content = Rect((Transform)(object)viewport, "Content", 0f, 0f, w - 28f, contentHeight);
			scroll.viewport = viewport;
			scroll.content = content;
			RectTransform val2 = Rect((Transform)(object)val, "Scrollbar", w - 24f, 2f, 24f, h - 4f);
			((Graphic)((Component)val2).gameObject.AddComponent<Image>()).color = Color.clear;
			Paint((Transform)(object)val2, "track", 9f, 0f, 6f, h - 4f);
			Scrollbar bar = ((Component)val2).gameObject.AddComponent<Scrollbar>();
			bar.direction = (Direction)2;
			RectTransform val3 = Rect((Transform)(object)Rect((Transform)(object)val2, "SlidingArea", 0f, 2f, 24f, h - 8f), "Handle", 0f, 0f, 24f, 24f);
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			Vector2 offsetMin = (val3.offsetMax = Vector2.zero);
			val3.offsetMin = offsetMin;
			Image obj = ((Component)val3).gameObject.AddComponent<Image>();
			obj.sprite = TraderSkinAssets.Get("diamond");
			obj.preserveAspect = true;
			Image val4 = Paint((Transform)(object)val3, "diamond", 0f, 0f, 24f, 16f, sliced: false);
			RectTransform rectTransform = ((Graphic)val4).rectTransform;
			RectTransform rectTransform2 = ((Graphic)val4).rectTransform;
			RectTransform rectTransform3 = ((Graphic)val4).rectTransform;
			Vector2 val5 = default(Vector2);
			((Vector2)(ref val5))..ctor(0.5f, 0.5f);
			rectTransform3.pivot = val5;
			offsetMin = (rectTransform2.anchorMax = val5);
			rectTransform.anchorMin = offsetMin;
			((Graphic)val4).rectTransform.anchoredPosition = Vector2.zero;
			((Component)val4).transform.localRotation = Quaternion.Euler(0f, 0f, 90f);
			((Graphic)obj).color = Color.clear;
			bar.handleRect = val3;
			((Selectable)bar).targetGraphic = (Graphic)(object)val4;
			bar.size = Mathf.Min(1f, 28f / (h - 8f));
			bar.SetValueWithoutNotify(1f);
			ScrollRect scroller = scroll;
			((UnityEvent<float>)(object)bar.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
			{
				scroller.verticalNormalizedPosition = v;
			});
			((UnityEvent<Vector2>)(object)scroll.onValueChanged).AddListener((UnityAction<Vector2>)delegate(Vector2 v)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				bar.SetValueWithoutNotify(v.y);
				Scrollbar obj2 = bar;
				Rect rect = content.rect;
				float height = ((Rect)(ref rect)).height;
				rect = viewport.rect;
				((Selectable)obj2).interactable = height > ((Rect)(ref rect)).height + 1f;
			});
			((Selectable)bar).interactable = contentHeight > h + 1f;
			return content;
		}

		public static Image Icon(Transform parent, Sprite sprite, float x, float y, float size)
		{
			Image obj = ((Component)Rect(parent, "Icon", x, y, size, size)).gameObject.AddComponent<Image>();
			obj.sprite = sprite;
			obj.preserveAspect = true;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		public static InventoryGrid Grid(Transform parent, Inventory bag, float x, float y, float width, float height, Action<InventoryGrid, ItemData, Vector2i, Modifier> select)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			InventoryGrid playerGrid = InventoryGui.instance.m_playerGrid;
			float num = Math.Min(1f, Math.Min((width - 4f) / ((float)bag.GetWidth() * playerGrid.m_elementSpace), (height - 4f) / ((float)bag.GetHeight() * playerGrid.m_elementSpace)));
			RectTransform val = Rect(parent, "NativeInventory", x, y, (float)bag.GetWidth() * playerGrid.m_elementSpace, (float)bag.GetHeight() * playerGrid.m_elementSpace);
			((Transform)val).localScale = Vector3.one * num;
			InventoryGrid val2 = ((Component)val).gameObject.AddComponent<InventoryGrid>();
			val2.m_gridRoot = Rect((Transform)(object)val, "Grid", 0f, 0f, val.sizeDelta.x, val.sizeDelta.y);
			val2.m_elementPrefab = playerGrid.m_elementPrefab;
			val2.m_elementSpace = playerGrid.m_elementSpace;
			val2.m_uiGroup = playerGrid.m_uiGroup;
			val2.m_tooltipAnchor = (RectTransform)parent;
			val2.m_showDropFocus = false;
			val2.m_onSelected = select;
			val2.m_onReleased = delegate(InventoryGrid g, ItemData item, Vector2i pos)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				TraderUI.Safe(delegate
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					TraderUI.Released(g, item, pos);
				});
			};
			val2.m_onRightClick = delegate(InventoryGrid g, ItemData item, Vector2i pos)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				TraderUI.Safe(delegate
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					TraderUI.RightClick(g, item, pos);
				});
			};
			val2.CanDropDragOntoItem = (ItemData item) => true;
			val2.UpdateInventory(bag, (Player)null, (ItemData)null);
			InventoryElement[] componentsInChildren = ((Component)val2).GetComponentsInChildren<InventoryElement>(true);
			foreach (InventoryElement val3 in componentsInChildren)
			{
				Image val4 = (Image)(Object.op_Implicit((Object)(object)val3.m_button) ? /*isinst with value type is only supported in some contexts*/: null);
				if (Object.op_Implicit((Object)(object)val4))
				{
					val4.sprite = TraderSkinAssets.Get("slot");
					val4.type = (Type)1;
					val4.pixelsPerUnitMultiplier = 5f;
					((Graphic)val4).color = Color.white;
				}
			}
			QuietFocus(((Component)val).gameObject, inventory: true);
			return val2;
		}

		private static void QuietFocus(GameObject root, bool inventory)
		{
			ButtonSfx[] componentsInChildren = root.GetComponentsInChildren<ButtonSfx>(true);
			foreach (ButtonSfx val in componentsInChildren)
			{
				val.m_selectSfxPrefab = null;
				val.m_selectSfxPrefabVibrationOnly = null;
				val.m_enterSfxPrefab = null;
				val.m_enterSfxPrefabVibrationOnly = null;
				if (inventory)
				{
					val.m_sfxPrefab = null;
					val.m_sfxPrefabVibrationOnly = null;
				}
			}
		}
	}
	internal sealed class TraderPreview
	{
		private GameObject root;

		private GameObject model;

		private Camera camera;

		private RenderTexture texture;

		private TraderNPC visual;

		private const int PreviewLayer = 30;

		private float nextLayers;

		private readonly List<Transform> layerTransforms = new List<Transform>();

		public void Create(Transform parent, float x, float y, float w, float h)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Expected O, but got Unknown
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			root = new GameObject("PT_CharacterPreview");
			root.SetActive(false);
			root.transform.position = new Vector3(0f, -10000f, 0f);
			model = Object.Instantiate<GameObject>(WorldObjects.TraderPrefab, root.transform);
			model.transform.localPosition = new Vector3(0f, 0.1f, 0f);
			model.transform.localRotation = Quaternion.identity;
			ZNetView[] componentsInChildren = model.GetComponentsInChildren<ZNetView>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Component)componentsInChildren[i]).gameObject.AddComponent<TraderPreviewOnly>();
			}
			Piece[] componentsInChildren2 = model.GetComponentsInChildren<Piece>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren2[i]);
			}
			visual = model.GetComponent<TraderNPC>();
			((Behaviour)visual).enabled = false;
			Collider[] componentsInChildren3 = model.GetComponentsInChildren<Collider>(true);
			for (int i = 0; i < componentsInChildren3.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren3[i]);
			}
			GameObject val = new GameObject("PreviewCamera");
			val.transform.SetParent(root.transform, false);
			camera = val.AddComponent<Camera>();
			((Component)camera).transform.localPosition = new Vector3(0f, 1.05f, 3.4f);
			((Component)camera).transform.LookAt(root.transform.position + new Vector3(0f, 1f, 0f));
			camera.clearFlags = (CameraClearFlags)2;
			camera.backgroundColor = new Color(0f, 0f, 0f, 0f);
			camera.cullingMask = 1073741824;
			camera.fieldOfView = 36f;
			camera.nearClipPlane = 0.1f;
			camera.farClipPlane = 8f;
			camera.renderingPath = (RenderingPath)(-1);
			camera.useOcclusionCulling = false;
			texture = new RenderTexture(512, 768, 24, (RenderTextureFormat)0);
			texture.Create();
			camera.targetTexture = texture;
			Vector3[] array = (Vector3[])(object)new Vector3[2]
			{
				new Vector3(-2f, 3f, 3f),
				new Vector3(2f, 2f, -1f)
			};
			foreach (Vector3 localPosition in array)
			{
				GameObject val2 = new GameObject("PreviewLight");
				val2.transform.SetParent(root.transform, false);
				val2.transform.localPosition = localPosition;
				Light obj = val2.AddComponent<Light>();
				obj.type = (LightType)2;
				obj.range = 8f;
				obj.intensity = 2.5f;
				obj.shadows = (LightShadows)0;
				obj.cullingMask = 1073741824;
			}
			RectTransform obj2 = NativeWidgets.Rect(parent, "TraderPreview", x, y, w, h);
			((Component)obj2).gameObject.AddComponent<RawImage>().texture = (Texture)(object)texture;
			((Component)obj2).gameObject.AddComponent<RotateTraderPreview>().Target = model.transform;
			model.SetActive(true);
			root.SetActive(true);
			Animator[] componentsInChildren4 = model.GetComponentsInChildren<Animator>(true);
			foreach (Animator obj3 in componentsInChildren4)
			{
				obj3.cullingMode = (AnimatorCullingMode)0;
				obj3.updateMode = (AnimatorUpdateMode)0;
				TraderPose.Stand(obj3);
			}
			componentsInChildren = model.GetComponentsInChildren<ZNetView>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Check.That(componentsInChildren[i].GetZDO() == null, "The preview must not create a world object");
			}
			Tick();
		}

		public void Apply(Look look, Dictionary<string, Item> equipment)
		{
			if (Object.op_Implicit((Object)(object)visual))
			{
				visual.ApplyLook(new Appearance
				{
					Look = look,
					Equipment = equipment
				});
			}
			nextLayers = 0f;
			Tick();
		}

		public void Tick()
		{
			if (!Object.op_Implicit((Object)(object)model) || Time.unscaledTime < nextLayers)
			{
				return;
			}
			nextLayers = Time.unscaledTime + 0.25f;
			model.GetComponentsInChildren<Transform>(true, layerTransforms);
			foreach (Transform layerTransform in layerTransforms)
			{
				if (((Component)layerTransform).gameObject.layer != 30)
				{
					((Component)layerTransform).gameObject.layer = 30;
				}
			}
		}

		public void Destroy()
		{
			if (Object.op_Implicit((Object)(object)camera))
			{
				camera.targetTexture = null;
			}
			if (Object.op_Implicit((Object)(object)root))
			{
				root.SetActive(false);
				Object.Destroy((Object)(object)root);
			}
			if (Object.op_Implicit((Object)(object)texture))
			{
				texture.Release();
				Object.Destroy((Object)(object)texture);
			}
			root = null;
			model = null;
			camera = null;
			visual = null;
			texture = null;
			layerTransforms.Clear();
		}
	}
	public sealed class TraderPreviewOnly : MonoBehaviour
	{
	}
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	internal static class PreviewNetworkInitialization
	{
		private static bool Prefix(ZNetView __instance)
		{
			return !Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<TraderPreviewOnly>());
		}
	}
	public sealed class RotateTraderPreview : MonoBehaviour, IDragHandler, IEventSystemHandler
	{
		public Transform Target;

		public void OnDrag(PointerEventData data)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Target))
			{
				Target.Rotate(Vector3.up, (0f - data.delta.x) * 0.6f, (Space)0);
			}
		}
	}
	internal static class TraderSkinAssets
	{
		private static readonly Dictionary<string, Texture2D> textures = new Dictionary<string, Texture2D>();

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

		private static Sprite Cut(string id, string file, int x, int y, int w, int h, float border = 0f)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (sprites.TryGetValue(id, out var value))
			{
				return value;
			}
			if (!textures.TryGetValue(file, out var value2))
			{
				value2 = (textures[file] = NativeWidgets.LoadTexture(file));
			}
			Sprite val2 = Sprite.Create(value2, new Rect((float)x, (float)(((Texture)value2).height - y - h), (float)w, (float)h), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4(border, border, border, border));
			sprites[id] = val2;
			return val2;
		}

		public static Sprite Get(string id)
		{
			return (Sprite)(id switch
			{
				"coins" => Cut(id, "trader-coins.png", 303, 255, 893, 590), 
				"button" => Cut(id, "trader-tabs.png", 40, 210, 1170, 326, 100f), 
				"button-on" => Cut(id, "trader-tabs.png", 40, 696, 1170, 326, 100f), 
				"input" => Cut(id, "trader-tabs.png", 40, 210, 1170, 326, 100f), 
				"input-on" => Cut(id, "trader-tabs.png", 40, 696, 1170, 326, 100f), 
				"slot" => Cut(id, "trader-controls.png", 52, 270, 674, 112, 20f), 
				"panel" => Cut(id, "trader-controls.png", 52, 459, 674, 160, 20f), 
				"panel-on" => Cut(id, "trader-controls.png", 805, 452, 686, 176, 26f), 
				"track" => Cut(id, "trader-controls.png", 356, 656, 60, 310, 16f), 
				"thumb" => Cut(id, "trader-controls.png", 1114, 653, 66, 316, 18f), 
				"crates" => Cut(id, "trader-icons.png", 132, 159, 302, 285), 
				"pouch" => Cut(id, "trader-icons.png", 639, 160, 281, 288), 
				"backpack" => Cut(id, "trader-icons.png", 1127, 157, 280, 292), 
				"pencil" => Cut(id, "trader-icons.png", 161, 620, 235, 255), 
				"trash" => Cut(id, "trader-icons.png", 662, 619, 212, 257), 
				"search" => Cut(id, "trader-icons.png", 1147, 623, 259, 256), 
				"pause" => Cut(id, "trader-order-actions.png", 321, 229, 294, 417), 
				"resume" => Cut(id, "trader-order-actions.png", 1183, 252, 290, 381), 
				"slider" => Cut(id, "trader-details.png", 60, 187, 709, 43, 16f), 
				"knob" => Cut(id, "trader-details.png", 1082, 147, 121, 123), 
				"close" => Cut(id, "trader-details.png", 317, 428, 167, 167), 
				"line" => Cut(id, "trader-details.png", 800, 508, 200, 10), 
				"diamond" => Cut(id, "trader-details.png", 1106, 490, 70, 46), 
				"progress" => Cut(id, "trader-details.png", 53, 777, 699, 77, 16f), 
				"fill" => Cut(id, "trader-details.png", 838, 790, 645, 47, 16f), 
				_ => throw new ArgumentException(id), 
			});
		}

		public static void Release()
		{
			foreach (Sprite value in sprites.Values)
			{
				if (Object.op_Implicit((Object)(object)value))
				{
					Object.Destroy((Object)(object)value);
				}
			}
			sprites.Clear();
			foreach (Texture2D value2 in textures.Values)
			{
				if (Object.op_Implicit((Object)(object)value2))
				{
					Object.Destroy((Object)(object)value2);
				}
			}
			textures.Clear();
		}
	}
	public sealed class TraderSkin : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, ISelectHandler, IDeselectHandler
	{
		private Image image;

		private Selectable control;

		private Sprite normal;

		private Sprite active;

		private bool selected;

		private bool hover;

		private bool marked;

		private bool focused;

		internal void Initialize(Selectable owner, Image target, string kind)
		{
			control = owner;
			image = target;
			normal = TraderSkinAssets.Get(kind);
			active = TraderSkinAssets.Get((kind == "close") ? kind : (kind + "-on"));
			Refresh();
			CanvasScaler val = (Object.op_Implicit((Object)(object)((Graphic)image).canvas) ? ((Component)((Graphic)image).canvas).GetComponent<CanvasScaler>() : null);
			float num = (Object.op_Implicit((Object)(object)val) ? val.referencePixelsPerUnit : (Object.op_Implicit((Object)(object)((Graphic)image).canvas) ? ((Graphic)image).canvas.referencePixelsPerUnit : 100f));
			image.pixelsPerUnitMultiplier = 8f * num / normal.pixelsPerUnit;
		}

		public void Highlight(bool value)
		{
			marked = true;
			selected = value;
			Refresh();
		}

		private void Refresh()
		{
			if (Object.op_Implicit((Object)(object)image))
			{
				image.sprite = ((selected || focused || (!marked && hover && control.IsInteractable())) ? active : normal);
			}
		}

		public void OnPointerEnter(PointerEventData e)
		{
			hover = true;
			Refresh();
		}

		public void OnPointerExit(PointerEventData e)
		{
			hover = false;
			Refresh();
		}

		public void OnSelect(BaseEventData e)
		{
			if (control is InputField)
			{
				focused = true;
				Refresh();
			}
		}

		public void OnDeselect(BaseEventData e)
		{
			focused = false;
			Refresh();
		}
	}
	public sealed class TraderFieldFocus : MonoBehaviour, ISelectHandler, IEventSystemHandler
	{
		public Action Selected;

		public void OnSelect(BaseEventData data)
		{
			Selected?.Invoke();
		}
	}
	internal static class TraderUI
	{
		public static bool Visible;

		private static ShopView view;

		private static GameObject root;

		private static GameObject page;

		private static Text notice;

		private static Text title;

		private static Text balance;

		private static Image footerCoin;

		private static CanvasGroup pageGroup;

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

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

		private static string tab = "stock";

		private static string message = "";

		private static string shopSearch = "";

		private static string notification = "";

		private static float notificationUntil;

		private static bool funding;

		private static bool selectingItem;

		private static string orderKey = "";

		private static string orderPrice = "1";

		private static string orderLimit = "0";

		private static string catalogSearch = "";

		private static bool orderPaused;

		private static List<Item> catalog;

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

		private static Look editLook;

		private static bool inputBlocked;

		private static TraderPreview preview;

		private static SplitDialog originalSplit;

		private static SplitDialog split;

		private static Inventory watched;

		private static bool inventoryDirty;

		private static float nextGridUpdate;

		private static PriceEdits priceEdits = new PriceEdits();

		private static Button savePrices;

		private static Button saveLook;

		private static Button cancelLook;

		private static readonly ShopVisit visit = new ShopVisit();

		private static readonly MethodInfo setupDrag = AccessTools.Method(typeof(InventoryGui), "SetupDragItem", (Type[])null, (Type[])null);

		private static readonly MethodInfo updateDrag = AccessTools.Method(typeof(InventoryGui), "UpdateItemDrag", (Type[])null, (Type[])null);

		private static readonly MethodInfo showSplit = AccessTools.Method(typeof(InventoryGui), "ShowSplitDialog", (Type[])null, (Type[])null);

		private static readonly MethodInfo hideSplit = AccessTools.Method(typeof(InventoryGui), "HideSplitDialog", (Type[])null, (Type[])null);

		private static readonly MethodInfo updateSplit = AccessTools.Method(typeof(InventoryGui), "UpdateSplitDialog", (Type[])null, (Type[])null);

		private static readonly Dictionary<string, FieldInfo> dragFields = new string[4] { "m_dragItem", "m_dragInventory", "m_dragAmount", "m_dragGo" }.ToDictionary((string name) => name, (string name) => AccessTools.Field(typeof(InventoryGui), name));

		private static bool IsDragging
		{
			get
			{
				if (Object.op_Implicit((Object)(object)InventoryGui.instance))
				{
					return Drag<ItemData>("m_dragItem") != null;
				}
				return false;
			}
		}

		internal static void Traded(string id, string action)
		{
			visit.Completed(id, action);
		}

		private static T Drag<T>(string field)
		{
			return (T)dragFields[field].GetValue(InventoryGui.instance);
		}

		public static void Safe(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				Exception ex2 = ((ex is TargetInvocationException && ex.InnerException != null) ? ex.InnerException : ex);
				Notify((ex2 is RuleException) ? ex2.Message : "Could not display item data");
				if (!(ex2 is RuleException))
				{
					Plugin.Error(ex2);
				}
			}
		}

		public static void Notify(string text)
		{
			text = L.Message(text);
			notification = text;
			notificationUntil = Time.unscaledTime + 8f;
			RefreshStatus();
			if (!Visible && Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null, false);
			}
		}

		public static void RefreshInput()
		{
			bool blockInput = Network.BlockInput;
			if (blockInput != inputBlocked)
			{
				GUIManager.BlockInput(blockInput);
				inputBlocked = blockInput;
			}
		}

		public static void ReleaseInput()
		{
			if (inputBlocked)
			{
				GUIManager.BlockInput(false);
			}
			inputBlocked = false;
		}

		public static void Show(ShopView value)
		{
			bool flag = Visible && view?.Id == value.Id;
			if (!flag || value.Revision >= view.Revision)
			{
				if (flag && view.IsOwner != value.IsOwner)
				{
					Close(send: false);
					flag = false;
				}
				if (!flag)
				{
					Close(send: false);
					InventoryGui.instance.Hide();
					tab = (value.IsOwner ? "stock" : "shop");
					editLook = Json.Copy(value.Look);
				}
				else if (Json.Write(view.Look) != Json.Write(value.Look))
				{
					editLook = Json.Copy(value.Look);
				}
				view = value;
				if (!view.IsOwner)
				{
					visit.Open(view.Id);
				}
				if (view.IsOwner)
				{
					priceEdits.Sync(SaleRows.From(view.Management));
				}
				if (!Object.op_Implicit((Object)(object)root))
				{
					Create();
				}
				Visible = true;
				root.SetActive(true);
				BuildPage();
				RefreshInput();
			}
		}

		private static void Create()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			float num = 1200f;
			float h = 720f;
			root = NativeWidgets.Panel(GUIManager.CustomGUIFront.transform, 0f, 0f, num, h);
			((Object)root).name = "PlayerTradersNativeUI";
			RectTransform val = (RectTransform)root.transform;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			val.pivot = val2;
			Vector2 anchorMin = (val.anchorMax = val2);
			val.anchorMin = anchorMin;
			val.anchoredPosition = Vector2.zero;
			title = NativeWidgets.Label(root.transform, "", 132f, 29f, 434f, 38f, 32, heading: true);
			title.alignment = (TextAnchor)3;
			title.resizeTextForBestFit = true;
			title.resizeTextMinSize = 22;
			title.resizeTextMaxSize = 32;
			title.horizontalOverflow = (HorizontalWrapMode)0;
			title.verticalOverflow = (VerticalWrapMode)0;
			NativeWidgets.Button(root.transform, "×", num - 94f, 28f, 40f, 40f, delegate
			{
				Close(send: true, gesture: true);
			});
			balance = NativeWidgets.Label(root.transform, "", 40f, 649f, 280f, 36f, 22);
			balance.alignment = (TextAnchor)3;
			balance.resizeTextForBestFit = true;
			balance.resizeTextMinSize = 18;
			balance.resizeTextMaxSize = 22;
			footerCoin = CurrencyGlyph.Attach(balance);
			notice = NativeWidgets.Label(root.transform, "", 590f, 27f, 500f, 42f);
			notice.alignment = (TextAnchor)4;
			notice.resizeTextForBestFit = true;
			notice.resizeTextMinSize = 12;
			notice.resizeTextMaxSize = 18;
			notice.horizontalOverflow = (HorizontalWrapMode)0;
			notice.verticalOverflow = (VerticalWrapMode)0;
			originalSplit = InventoryGui.instance.m_splitDialog;
			split = Object.Instantiate<SplitDialog>(originalSplit, root.transform, false);
			((Component)split).gameObject.SetActive(false);
			InventoryGui.instance.m_splitDialog = split;
			watched = ((Humanoid)Player.m_localPlayer).GetInventory();
			Inventory obj = watched;
			obj.m_onChanged = (Action)Delegate.Combine(obj.m_onChanged, new Action(InventoryChanged));
		}

		private static void InventoryChanged()
		{
			inventoryDirty = true;
		}

		public static void Close(bool send = true, bool gesture = false)
		{
			//IL_007e: 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)
			if (gesture && Network.Busy)
			{
				Notify(L.Text("Please wait…"));
				return;
			}
			if (Visible)
			{
				TraderOfferMarker.Viewed(view);
			}
			string text = visit.Close(gesture);
			if (text != null && Visible && view != null && Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Character)Player.m_localPlayer).IsDead())
			{
				TraderNPC traderNPC = TraderNPC.Find(view.Id);
				if (Object.op_Implicit((Object)(object)traderNPC) && Vector3.Distance(((Component)traderNPC).transform.position, ((Component)Player.m_localPlayer).transform.position) <= 5f)
				{
					traderNPC.Farewell(text);
				}
			}
			if (Object.op_Implicit((Object)(object)InventoryGui.instance) && Object.op_Implicit((Object)(object)root))
			{
				CancelDrag();
				hideSplit.Invoke(InventoryGui.instance, null);
				InventoryGui.instance.m_splitDialog = originalSplit;
			}
			if (watched != null)
			{
				Inventory obj = watched;
				obj.m_onChanged = (Action)Delegate.Remove(obj.m_onChanged, new Action(InventoryChanged));
			}
			watched = null;
			preview?.Destroy();
			preview = null;
			grids.Clear();
			inventories.Clear();
			if (Object.op_Implicit((Object)(object)root))
			{
				Object.Destroy((Object)(object)root);
			}
			root = null;
			page = null;
			notice = null;
			title = null;
			balance = null;
			footerCoin = null;
			pageGroup = null;
			editLook = null;
			split = null;
			originalSplit = null;
			Visible = false;
			view = null;
			inventoryDirty = false;
			priceEdits = new PriceEdits();
			savePrices = (saveLook = (cancelLook = null));
			quantities.Clear();
			catalog = null;
			selectingItem = false;
			orderKey = "";
			notification = "";
			notificationUntil = 0f;
			if (send && Object.op_Implicit((Object)(object)ZNet.instance))
			{
				Network.Close();
			}
			RefreshInput();
		}

		private static void CancelDrag()
		{
			if (Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				setupDrag.Invoke(InventoryGui.instance, new object[3] { null, null, 1 });
			}
		}

		private static Request Request(string action)
		{
			return new Request
			{
				Action = action,
				Trader = view.Id,
				Revision = view.Revision
			};
		}

		private static void Submit(Request request)
		{
			if (Network.Busy)
			{
				return;
			}
			if (inventoryDirty && (request.Action == "move" || request.Action == "equipPlayer" || request.Action == "unequip"))
			{
				CancelDrag();
				BuildPage();
				Notify(L.Text("Inventory changed. Slots refreshed — try moving the item again."));
				return;
			}
			Network.Operate(request);
			if (Network.Busy)
			{
				CancelDrag();
			}
		}

		private static void Choose(string next)
		{
			if (!(tab == next) || selectingItem)
			{
				tab = next;
				selectingItem = false;
				BuildPage();
			}
		}

		private static void BuildPage()
		{
			if (!Object.op_Implicit((Object)(object)root) || view == null)
			{
				return;
			}
			hideSplit.Invoke(InventoryGui.instance, null);
			CancelDrag();
			preview?.Destroy();
			preview = null;
			if (Object.op_Implicit((Object)(object)page))
			{
				page.SetActive(false);
				Object.Destroy((Object)(object)page);
			}
			grids.Clear();
			inventories.Clear();
			savePrices = (saveLook = (cancelLook = null));
			title.text = L.Format("{0} — {1}", view.Look.Name, view.IsOwner ? L.Text("Management") : L.Text("Trading"));
			float num = Mathf.Min(434f, title.preferredWidth + 6f);
			NativeWidgets.Place(((Graphic)title).rectTransform, 132f, 29f, num, 38f);
			float num2 = 132f + num + 16f;
			NativeWidgets.Place(((Graphic)notice).rectTransform, num2, 27f, 1090f - num2, 42f);
			page = ((Component)NativeWidgets.Rect(root.transform, "Page", 16f, 76f, 1168f, 600f)).gameObject;
			pageGroup = page.AddComponent<CanvasGroup>();
			if (view.IsOwner)
			{
				string[] array = new string[5] { "stock", "sales", "orders", "cash", "look" };
				string[] array2 = new string[5]
				{
					L.Text("Stock"),
					L.Text("Sale prices"),
					L.Text("Buy orders"),
					L.Text("Till"),
					L.Text("Appearance")
				};
				for (int i = 0; i < array.Length; i++)
				{
					string key = array[i];
					NativeWidgets.Tab(page.transform, array2[i], 116 + i * 194, -2f, 174f, 34f, key == tab, delegate
					{
						Choose(key);
					});
				}
			}
			else
			{
				NativeWidgets.Tab(page.transform, L.Text("Selling"), 116f, -2f, 220f, 34f, tab == "shop", delegate
				{
					Choose("shop");
				});
				NativeWidgets.Tab(page.transform, L.Text("Buying"), 368f, -2f, 220f, 34f, tab == "buying", delegate
				{
					Choose("buying");
				});
				Text obj = NativeWidgets.Label(page.transform, L.Format("You have: {0}", Coins()), 880f, -4f, 206f, 34f, 24, heading: true);
				obj.alignment = (TextAnchor)3;
				obj.resizeTextForBestFit = true;
				obj.resizeTextMinSize = 14;
				obj.resizeTextMaxSize = 24;
				CurrencyGlyph.Attach(obj);
			}
			switch (tab)
			{
			case "stock":
				Stock();
				break;
			case "sales":
				Sales();
				break;
			case "orders":
				Orders();
				break;
			case "cash":
				Cash();
				break;
			case "look":
				Look();
				break;
			default:
				Shop();
				break;
			}
			if (view.IsOwner && tab != "look" && tab != "cash")
			{
				message = L.Format("Till: {0}", view.Management.Cash);
			}
			else
			{
				message = "";
			}
			balance.text = message;
			float w = Mathf.Min(280f, balance.preferredWidth + 4f);
			NativeWidgets.Place(((Graphic)balance).rectTransform, 40f, 649f, w, 36f);
			RefreshStatus();
			((Component)split).transform.SetAsLastSibling();
			inventoryDirty = false;
		}

		private static void RefreshStatus()
		{
			if (Object.op_Implicit((Object)(object)notice))
			{
				bool flag = Time.unscaledTime < notificationUntil;
				notice.text = (Network.Busy ? L.Text("Please wait…") : (flag ? notification : ""));
				bool active = !string.IsNullOrEmpty(message);
				((Component)balance).gameObject.SetActive(active);
				((Component)footerCoin).gameObject.SetActive(active);
			}
		}

		private static void AddGrid(string name, Bag bag, float x, float y, float w, float h)
		{
			Inventory val = NativeInventoryMove.Mirror(bag);
			inventories[name] = val;
			InventoryGrid key = NativeWidgets.Grid(page.transform, val, x, y, w, h, delegate(InventoryGrid g, ItemData i, Vector2i p, Modifier m)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				Safe(delegate
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					Selected(g, i, p, m);
				});
			});
			grids.Add(key, name);
		}

		private static void Stock()
		{
			Transform transform = page.transform;
			NativeWidgets.Board(transform, 12f, 64f, 372f, 489f);
			NativeWidgets.Board(transform, 394f, 64f, 372f, 489f);
			NativeWidgets.Board(transform, 778f, 64f, 378f, 489f);
			NativeWidgets.Icon(transform, TraderSkinAssets.Get("crates"), 22f, 66f, 36f);
			NativeWidgets.Label(transform, L.Text("For sale — 50 slots"), 64f, 71f, 306f, 32f, 23, heading: true);
			NativeWidgets.Icon(transform, TraderSkinAssets.Get("pouch"), 404f, 66f, 36f);
			NativeWidgets.Label(transform, L.Text("Purchased — 50 slots"), 446f, 71f, 306f, 32f, 23, heading: true);
			NativeWidgets.Icon(transform, TraderSkinAssets.Get("backpack"), 792f, 66f, 36f);
			NativeWidgets.Label(transform, L.Text("Your inventory"), 834f, 71f, 302f, 32f, 23, heading: true);
			NativeWidgets.Line(transform, 20f, 108f, 354f);
			NativeWidgets.Line(transform, 402f, 108f, 354f);
			NativeWidgets.Line(transform, 790f, 108f, 348f);
			ScrollGrid("stock", Warehouses.Part(view.Management.Stock, purchased: false), 20f, 116f, 356f, 428f);
			ScrollGrid("purchased", Warehouses.Part(view.Management.Stock, purchased: true), 402f, 116f, 356f, 428f);
			AddGrid("player", Items.Snapshot(((Humanoid)Player.m_localPlayer).GetInventory()), 788f, 116f, 358f, 300f);
			Text obj = NativeWidgets.Label(transform, L.Text("LMB — move     Shift — split     Ctrl — quick move"), 348f, 576f, 660f, 30f, 17);
			obj.alignment = (TextAnchor)4;
			obj.resizeTextForBestFit = true;
			obj.resizeTextMinSize = 13;
			obj.resizeTextMaxSize = 17;
		}

		private static void ScrollGrid(string name, Bag bag, float x, float y, float w, float h)
		{
			float num = Math.Min(InventoryGui.instance.m_playerGrid.m_elementSpace, (w - 28f) / (float)bag.Width);
			ScrollRect scroll;
			RectTransform parent = NativeWidgets.Scroll(page.transform, x, y, w, h, (float)bag.Height * num + 4f, out scroll);
			Inventory val = NativeInventoryMove.Mirror(bag);
			inventories[name] = val;
			InventoryGrid key = NativeWidgets.Grid((Transform)(object)parent, val, 0f, 0f, w - 24f, (float)bag.Height * num + 4f, delegate(InventoryGrid g, ItemData i, Vector2i p, Modifier m)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				Safe(delegate
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					Selected(g, i, p, m);
				});
			});
			grids.Add(key, name);
		}

		private static string SourceName(Inventory inv)
		{
			return inventories.FirstOrDefault((KeyValuePair<string, Inventory> p) => p.Value == inv).Key;
		}

		private static void StartDrag(ItemData item, Inventory inv, int count)
		{
			setupDrag.Invoke(InventoryGui.instance, new object[3] { item, inv, count });
			RaiseDrag();
		}

		private static void RaiseDrag()
		{
			GameObject val = Drag<GameObject>("m_dragGo");
			if (Object.op_Implicit((Object)(object)val))
			{
				val.transform.SetParent(root.transform, false);
				val.transform.SetAsLastSibling();
				(val.GetComponent<CanvasGroup>() ?? val.AddComponent<CanvasGroup>()).blocksRaycasts = false;
			}
		}

		private static void Selected(InventoryGrid grid, ItemData item, Vector2i pos, Modifier modifier)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			if (Network.Busy || !grids.ContainsKey(grid))
			{
				return;
			}
			if (IsDragging)
			{
				Drop(grid, pos);
			}
			else
			{
				if (item == null)
				{
					return;
				}
				string text = grids[grid];
				Check.That(!item.m_equipped, "Unequip the item first");
				if ((int)modifier == 1 && item.m_stack > 1 && text != "equipment")
				{
					showSplit.Invoke(InventoryGui.instance, new object[2]
					{
						item,
						grid.GetInventory()
					});
					((Component)split).transform.SetAsLastSibling();
				}
				else if ((int)modifier == 2 || (int)modifier == 3)
				{
					if (text == "equipment")
					{
						Unequip(item.m_gridPos.x, -1);
						return;
					}
					if (tab == "look")
					{
						Equip(item, text, null);
						return;
					}
					Request request = Request("move");
					request.Source = text;
					request.Target = ((text == "player") ? "stock" : "player");
					request.Slot = item.m_gridPos.y * grid.GetInventory().GetWidth() + item.m_gridPos.x;
					request.Count = item.m_stack;
					Submit(request);
				}
				else
				{
					StartDrag(item, grid.GetInventory(), item.m_stack);
				}
			}
		}

		public static void Released(InventoryGrid grid, ItemData item, Vector2i pos)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDragging || Network.Busy)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)grid))
			{
				CancelDrag();
				return;
			}
			ItemData val = Drag<ItemData>("m_dragItem");
			if (Drag<Inventory>("m_dragInventory") != grid.GetInventory() || !(val.m_gridPos == pos))
			{
				Drop(grid, pos);
			}
		}

		public static void MouseDragEnded(UIDragHandler source, PointerEventData data)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (!Visible || ZInput.IsTouchActive() || (int)data.button != 0 || !IsDragging)
			{
				return;
			}
			InventoryGrid componentInParent = ((Component)source).GetComponentInParent<InventoryGrid>();
			if (Object.op_Implicit((Object)(object)componentInParent) && grids.ContainsKey(componentInParent))
			{
				RaycastResult pointerCurrentRaycast = data.pointerCurrentRaycast;
				GameObject gameObject = ((RaycastResult)(ref pointerCurrentRaycast)).gameObject;
				InventoryElement val = (Object.op_Implicit((Object)(object)gameObject) ? gameObject.GetComponentInParent<InventoryElement>() : null);
				InventoryGrid val2 = (Object.op_Implicit((Object)(object)val) ? ((Component)val).GetComponentInParent<InventoryGrid>() : null);
				if (Object.op_Implicit((Object)(object)val2) && grids.ContainsKey(val2))
				{
					Vector2i pos = (Vector2i)AccessTools.Method(typeof(InventoryGrid), "GetElementPos", (Type[])null, (Type[])null).Invoke(val2, new object[1] { val });
					Released(val2, null, pos);
				}
			}
		}

		public static void RightClick(InventoryGrid grid, ItemData item, Vector2i pos)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (Network.Busy)
			{
				return;
			}
			if (IsDragging)
			{
				CancelDrag();
			}
			else if (!(tab != "look") && item != null)
			{
				if (grids[grid] == "equipment")
				{
					Unequip(pos.x, -1);
				}
				else
				{
					Equip(item, grids[grid], null);
				}
			}
		}

		private static void Drop(InventoryGrid target, Vector2i pos)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDragging || !grids.TryGetValue(target, out var value))
			{
				return;
			}
			ItemData val = Drag<ItemData>("m_dragItem");
			Inventory val2 = Drag<Inventory>("m_dragInventory");
			string text = SourceName(val2);
			Check.That(text != null, L.Text("The item has moved. Select it again."));
			int num = pos.y * target.GetInventory().GetWidth() + pos.x;
			if (value == "equipment")
			{
				Check.That(pos.y == 0 && pos.x >= 0 && pos.x < Rules.Slots.Length, "Only head, chest, legs, shoulders and accessory slots are supported");
				if (text == "equipment")
				{
					CancelDrag();
				}
				else
				{
					Equip(val, text, Rules.Slots[pos.x]);
				}
				return;
			}
			if (text == "equipment")
			{
				Check.That(value == "player", "Choose where to return the clothing");
				Unequip(val.m_gridPos.x, num);
				return;
			}
			Check.That(value != "purchased" || text == "purchased", L.Text("Purchased stock can only be filled by purchases"));
			int num2 = val.m_gridPos.y * val2.GetWidth() + val.m_gridPos.x;
			if (text == value && num2 == num)
			{
				CancelDrag();
				return;
			}
			Request request = Request("move");
			request.Source = text;
			request.Target = value;
			request.Slot = num2;
			request.TargetSlot = num;
			request.Count = Drag<int>("m_dragAmount");
			Submit(request);
		}

		private static void Equip(ItemData item, string source, string slot)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Check.That(source == "player", "Choose where to return the clothing");
			string text = Items.EquipmentSlot(item.m_shared.m_itemType);
			Check.That(Rules.Slots.Contains(text) && (slot == null || slot == text), L.Text("Place clothing in the matching slot"));
			Request request = Request("equipPlayer");
			request.Slot = item.m_gridPos.y * inventories[source].GetWidth() + item.m_gridPos.x;
			request.Target = "player";
			request.Key = text;
			Submit(request);
		}

		private static void Unequip(int index, int targetSlot)
		{
			Check.That(index >= 0 && index < Rules.Slots.Length, "Only head, chest, legs, shoulders and accessory slots are supported");
			Request request = Request("unequip");
			request.Key = Rules.Slots[index];
			request.Target = "player";
			request.TargetSlot = targetSlot;
			Submit(request);
		}

		private static void Sales()
		{
			NativeWidgets.Icon(page.transform, TraderSkinAssets.Get("crates"), 24f, 66f, 34f);
			NativeWidgets.Label(page.transform, L.Text("Item"), 70f, 71f, 440f, 30f, 23, heading: true);
			NativeWidgets.Icon(page.transform, TraderSkinAssets.Get("crates"), 508f, 66f, 32f);
			NativeWidgets.Label(page.transform, L.Text("For sale"), 552f, 71f, 180f, 30f, 23, heading: true);
			CurrencyGlyph.Attach(NativeWidgets.Label(page.transform, L.Text("Coins per item"), 886f, 71f, 250f, 30f, 23, heading: true), before: true, 1.55f);
			List<SaleRow> list = SaleRows.From(view.Management);
			ScrollRect scroll;
			RectTransform val = NativeWidgets.Scroll(page.transform, 16f, 110f, 1138f, 374f, Math.Max(374, list.Count * 68), out scroll);
			for (int i = 0; i < list.Count; i++)
			{
				SaleRow entry = list[i];
				float num = i * 68;
				NativeWidgets.Surface((Transform)(object)val, 2f, num + 2f, 1098f, 62f);
				NativeWidgets.Icon((Transform)(object)val, Items.Icon(entry.Sample), 16f, num + 8f, 46f);
				NativeWidgets.Label((Transform)(object)val, Items.Name(entry.Sample), 82f, num + 13f, 430f, 42f, 21);
				NativeWidgets.Label((Transform)(object)val, entry.Quantity.ToString(), 538f, num + 15f, 120f, 30f, 21);
				if (entry.Sample.Prefab == "Coins")
				{
					NativeWidgets.Label((Transform)(object)val, L.Text("Currency"), 860f, num + 15f, 190f, 30f);
					continue;
				}
				((UnityEvent<string>)(object)NativeWidgets.Field((Transform)(object)val, priceEdits.Get(entry.Key), 866f, num + 13f, 180f, 38f, number: true).onValueChanged).AddListener((UnityAction<string>)delegate(string value)
				{
					priceEdits.Set(entry.Key, value);
					RefreshSaveButtons();
				});
			}
			if (list.Count == 0)
			{
				NativeWidgets.Label((Transform)(object)val, L.Text("There are no items for sale yet."), 24f, 24f, 1040f, 46f, 22);
			}
			NativeWidgets.Line(page.transform, 20f, 502f, 1118f);
			NativeWidgets.Icon(page.transform, TraderSkinAssets.Get("crates"), 24f, 514f, 30f);
			NativeWidgets.Label(page.transform, L.Text("Only items from the For sale section."), 64f, 514f, 740f, 30f);
			savePrices = NativeWidgets.Button(page.transform, L.Text("Save"), 780f, 574f, 222f, 34f, delegate
			{
				Dictionary<string, int> dictionary = priceEdits.Changes();
				if (dictionary.Count != 0)
				{
					Request request = Request("prices");
					request.Prices = dictionary;
					Submit(request);
				}
			});
			RefreshSaveButtons();
		}

		private static long Coins()
		{
			return (from i in ((Humanoid)Player.m_localPlayer).GetInventory().GetAllItems()
				where Object.op_Implicit((Object)(object)i.m_dropPrefab) && ((Object)i.m_dropPrefab).name == "Coins"
				select i).Sum((Func<ItemData, long>)((ItemData i) => i.m_stack));
		}

		private static InputField Quantity(Transform parent, string key, float x, float y, int max, Action<int> changed)
		{
			int value;
			InputField field = NativeWidgets.Field(parent, Math.Max(1, Math.Min(max, (!quantities.TryGetValue(key, out value)) ? 1 : value)).ToString(), x + 44f, y, 76f, 38f, number: true);
			field.textComponent.alignment = (TextAnchor)4;
			NativeWidgets.Button(parent, "−", x, y + 2f, 34f, 34f, delegate
			{
				int.TryParse(field.text, out var result);
				field.text = Math.Max(1, result - 1).ToString();
			});
			NativeWidgets.Button(parent, "+", x + 130f, y + 2f, 34f, 34f, delegate
			{
				int.TryParse(field.text, out var result);
				field.text = Math.Max(1L, Math.Min(max, (long)result + 1L)).ToString();
			});
			((UnityEvent<string>)(object)field.onValueChanged).AddListener((UnityAction<string>)Apply);
			((UnityEvent<string>)(object)field.onEndEdit).AddListener((UnityAction<string>)delegate(string text)
			{
				int.TryParse(text, out var result);
				field.text = Math.Max(1, Math.Min(max, result)).ToString();
			});
			Apply(field.text);
			return field;
			void Apply(string text)
			{
				int result;
				int num = (int.TryParse(text, out result) ? Math.Max(0, Math.Min(max, result)) : 0);
				quantities[key] = num;
				changed(num);
			}
		}

		private static void Shop()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			bool buying = tab == "buying";
			InputField obj = NativeWidgets.Field(page.transform, shopSearch, 20f, 61f, 1112f, 38f);
			obj.characterLimit = 100;
			((Component)obj.placeholder).GetComponent<Text>().text = L.Text("Search by name…");
			NativeWidgets.Icon(((Component)obj).transform, TraderSkinAssets.Get("search"), 10f, 7f, 24f);
			RectTransform rectTransform = ((Graphic)obj.textComponent).rectTransform;
			rectTransform.offsetMin += new Vector2(30f, 0f);
			RectTransform rectTransform2 = obj.placeholder.rectTransform;
			rectTransform2.offsetMin += new Vector2(30f, 0f);
			ScrollRect scroll;
			RectTransform content = NativeWidgets.Scroll(page.transform, 16f, 150f, 1138f, 398f, 398f, out scroll);
			NativeWidgets.Label(page.transform, L.Text("Item"), 38f, 111f, 420f, 30f, 21);
			NativeWidgets.Label(page.transform, buying ? L.Text("Per item") : L.Text("Price"), 446f, 111f, 140f, 30f, 21);
			NativeWidgets.Label(page.transform, buying ? L.Text("Wanted") : L.Text("In stock"), 607f, 111f, 155f, 30f, 21);
			Bag stock = Items.Snapshot(((Humanoid)Player.m_localPlayer).GetInventory());
			((UnityEvent<string>)(object)obj.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				Safe(delegate
				{
					shopSearch = value;
					Rows();
				});
			});
			Rows();
			void Rows()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				foreach (Transform item in (Transform)content)
				{
					((Component)item).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				List<(string, Item, int, long, long)> source = (buying ? view.Buying.Select((BuyingListing buyingListing) => (Key: buyingListing.Key, Sample: buyingListing.Sample, Price: buyingListing.Price, Quantity: buyingListing.Remaining, Available: buyingListing.Affordable)).ToList() : view.Listings.Select((Listing listing) => (Key: listing.Key, Sample: listing.Sample, Price: listing.Price, Quantity: listing.Quantity, Available: listing.Quantity)).ToList());
				source = source.Where<(string, Item, int, long, long)>(((string Key, Item Sample, int Price, long Quantity, long Available) tuple) => Items.Name(tuple.Sample).IndexOf(shopSearch, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
				content.sizeDelta = new Vector2(1116f, (float)Math.Max(398, source.Count * 94));
				for (int num = 0; num < source.Count; num++)
				{
					(string Key, Item Sample, int Price, long Quantity, long Available) e = source[num];
					float num2 = num * 94;
					int quantity = 1;
					NativeWidgets.Surface((Transform)(object)content, 2f, num2 + 2f, 1098f, 86f);
					NativeWidgets.Icon((Transform)(object)content, Items.Icon(e.Sample), 18f, num2 + (float)(buying ? 17 : 14), 56f);
					Text val2 = NativeWidgets.Label((Transform)(object)content, Items.Name(e.Sample), 94f, num2 + (float)(buying ? 31 : 8), 328f, 28f, 22);
					if (buying)
					{
						val2.alignment = (TextAnchor)3;
					}
					NativeWidgets.Label((Transform)(object)content, buying ? L.Format("{0} coins / item", e.Price) : Items.Description(e.Sample), 94f, num2 + (float)(buying ? 61 : 38), 324f, buying ? 22 : 40, 15).verticalOverflow = (VerticalWrapMode)0;
					Text price = NativeWidgets.Label((Transform)(object)content, "", 446f, num2 + 26f, 120f, 38f, 23);
					price.alignment = (TextAnchor)3;
					price.resizeTextForBestFit = true;
					price.resizeTextMinSize = 12;
					price.resizeTextMaxSize = 23;
					CurrencyGlyph.Attach(price);
					NativeWidgets.Label((Transform)(object)content, (e.Quantity < 0) ? "∞" : L.Format("{0} pcs.", e.Quantity), 603f, num2 + 26f, 142f, 38f, 21).alignment = (TextAnchor)3;
					long val3 = (buying ? stock.Items.Where((Item item) => item.Prefab == e.Key && !item.Equipped).Sum((Func<Item, long>)((Item item) => item.Count)) : long.MaxValue);
					int max = (int)Math.Min(2147483647L, Math.Min(e.Available, val3));
					Button trade = NativeWidgets.Button((Transform)(object)content, buying ? L.Text("Sell") : L.Text("Buy"), 942f, num2 + 24f, 148f, 42f, delegate
					{
						Request request = Request(buying ? "sell" : "buy");
						request.Key = e.Key;
						request.Count = quantity;
						Submit(request);
					});
					Quantity((Transform)(object)content, (buying ? "sell:" : "buy:") + e.Key, 756f, num2 + 26f, max, delegate(int n)
					{
						quantity = n;
						long num3 = (long)e.Price * (long)n;
						price.text = num3.ToString();
						((Selectable)trade).interactable = n > 0 && n <= max && num3 <= int.MaxValue && (buying || Coins() >= num3);
						NativeWidgets.Mark((Selectable)(object)trade, ((Selectable)trade).interactable);
					});
				}
				if (source.Count == 0)
				{
					NativeWidgets.Label((Transform)(object)content, buying ? L.Text("No active buy orders") : L.Text("No items"), 24f, 30f, 1040f, 44f, 24, heading: true);
				}
			}
		}

		private static void Cash()
		{
			Transform transform = page.transform;
			long cash = view.Management.Cash;
			long num = Coins();
			NativeWidgets.Tab(transform, L.Text("Withdraw"), 344f, 72f, 222f, 38f, !funding, delegate
			{
				funding = false;
				BuildPage();
			});
			NativeWidgets.Tab(transform, L.Text("Deposit"), 590f, 72f, 222f, 38f, funding, delegate
			{
				funding = true;
				BuildPage();
			});
			NativeWidgets.Line(transform, 20f, 138f, 1118f);
			CashBalances(transform, cash, num);
			NativeWidgets.Line(transform, 20f, 360f, 1118f);
			NativeWidgets.Label(transform, funding ? L.Text("Amount to deposit:") : L.Text("Amount to withdraw:"), 252f, 408f, 290f, 38f, 23);
			int quantity = 1;
			Button action = NativeWidgets.Button(transform, funding ? L.Text("Deposit") : L.Text("Withdraw"), 416f, 476f, 332f, 48f, delegate
			{
				Request request = Request(funding ? "fund" : "cash");
				request.Count = quantity;
				Submit(request);
			});
			int max = (int)Math.Min(2147483647L, funding ? num : cash);
			Quantity(transform, funding ? "fund" : "cash", 562f, 407f, max, delegate(int n)
			{
				quantity = n;
				((Selectable)action).interactable = n > 0 && n <= max;
				NativeWidgets.Mark((Selectable)(object)action, ((Selectable)action).interactable);
			});
		}

		private static void CashBalances(Transform parent, long cash, long coins)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			Text val = NativeWidgets.Label(parent, L.Format("Till: {0}", cash), 0f, 188f, 940f, 64f, 36, heading: true);
			Text val2 = NativeWidgets.Label(parent, L.Format("You have: {0}", coins), 0f, 278f, 940f, 40f, 27, heading: true);
			float num = Mathf.Min(940f, val.preferredWidth + 4f);
			float num2 = Mathf.Min(940f, val2.preferredWidth + 4f);
			float x = (1168f - Mathf.Max(num + 42f, num2 + 32f)) / 2f;
			NativeWidgets.Place(((Graphic)val).rectTransform, x, 188f, num, 64f);
			NativeWidgets.Place(((Graphic)val2).rectTransform, x, 278f, num2, 40f);
			TextAnchor alignment = (TextAnchor)3;
			val2.alignment = (TextAnchor)3;
			val.alignment = alignment;
			CurrencyGlyph.Attach(val);
			CurrencyGlyph.Attach(val2);
		}

		private static void SelectOrder(string key)
		{
			orderKey = key;
			BuyOrder value;
			BuyOrder obj = (view.Management.Orders.TryGetValue(key, out value) ? value : null);
			orderPrice = (obj?.Price ?? 1).ToString();
			orderLimit = (obj?.Limit ?? 0).ToString();
			orderPaused = obj?.Paused ?? false;
			selectingItem = false;
			BuildPage();
		}

		private static void Orders()
		{
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_050d: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = page.transform;
			NativeWidgets.Icon(transform, TraderSkinAssets.Get("pouch"), 24f, 66f, 38f);
			NativeWidgets.Label(transform, L.Format("Buy orders — {0}", view.Management.Orders.Count), 76f, 71f, 720f, 34f, 24, heading: true);
			NativeWidgets.Button(transform, selectingItem ? L.Text("Back") : L.Text("Add item  +"), 866f, 68f, 266f, 40f, delegate
			{
				selectingItem = !selectingItem;
				if (selectingItem)
				{
					catalog = Items.KnownItems();
				}
				BuildPage();
			});
			if (selectingItem)
			{
				Catalog();
				return;
			}
			List<KeyValuePair<string, BuyOrder>> list = view.Management.Orders.ToList();
			ScrollRect scroll;
			RectTransform val = NativeWidgets.Scroll(transform, 16f, 153f, 1138f, 194f, Math.Max(194, list.Count * 64 + 20), out scroll);
			NativeWidgets.Label(transform, L.Text("Item"), 82f, 121f, 270f, 26f);
			NativeWidgets.Label(transform, L.Text("Price (coins)"), 366f, 121f, 150f, 26f);
			NativeWidgets.Label(transform, L.Text("Target quantity"), 528f, 121f, 155f, 26f);
			NativeWidgets.Label(transform, L.Text("Progress"), 684f, 121f, 166f, 26f);
			NativeWidgets.Label(transform, L.Text("Status"), 860f, 121f, 130f, 26f);
			for (int num = 0; num < list.Count; num++)
			{
				KeyValuePair<string, BuyOrder> e = list[num];
				float num2 = 10 + num * 64;
				NativeWidgets.Tab((Transform)(object)val, "", 12f, num2 + 2f, 1078f, 43f, e.Key == orderKey, delegate
				{
					SelectOrder(e.Key);
				});
				NativeWidgets.Icon((Transform)(object)val, Items.Icon(e.Value.Sample), 16f, num2 + 5f, 40f);
				NativeWidgets.Label((Transform)(object)val, Items.Name(e.Value.Sample), 76f, num2 + 10f, 265f, 34f, 20);
				NativeWidgets.Label((Transform)(object)val, e.Value.Price.ToString(), 352f, num2 + 10f, 138f, 32f, 20);
				NativeWidgets.Label((Transform)(object)val, (e.Value.Limit == 0) ? "∞" : e.Value.Limit.ToString(), 514f, num2 + 10f, 130f, 32f, 20);
				if (e.Value.Limit > 0)
				{
					NativeWidgets.Paint((Transform)(object)val, "progress", 650f, num2 + 14f, 160f, 22f);
					float num3 = 150f * Mathf.Clamp01((float)e.Value.Received / (float)e.Value.Limit);
					if (num3 > 0f)
					{
						NativeWidgets.Paint((Transform)(object)val, "fill", 655f, num2 + 19f, num3, 12f);
					}
				}
				Text obj = NativeWidgets.Label((Transform)(object)val, (e.Value.Limit == 0) ? "—" : (e.Value.Received + " / " + e.Value.Limit), 654f, num2 + 14f, 152f, 22f, 14);
				obj.alignment = (TextAnchor)4;
				obj.resizeTextForBestFit = true;
				obj.resizeTextMinSize = 9;
				obj.resizeTextMaxSize = 14;
				((Graphic)obj).color = Color.white;
				Text obj2 = NativeWidgets.Label((Transform)(object)val, e.Value.Paused ? L.Text("Paused") : ((e.Value.Remaining == 0L) ? L.Text("Complete") : L.Text("● Active")), 842f, num2 + 10f, 130f, 32f, 17);
				obj2.alignment = (TextAnchor)3;
				((Graphic)obj2).color = (e.Value.Paused ? new Color(1f, 0.65f, 0.2f) : new Color(0.6f, 0.83f, 0.4f));
			}
			NativeWidgets.Surface(transform, 18f, 358f, 1060f, 187f);
			if (string.IsNullOrEmpty(orderKey))
			{
				NativeWidgets.Label(transform, L.Text("Add an item or select an order to edit."), 46f, 408f, 1000f, 48f, 22);
				return;
			}
			Item i = Items.Factory(orderKey);
			NativeWidgets.Label(transform, L.Text("Item settings"), 42f, 365f, 420f, 32f, 22, heading: true);
			NativeWidgets.Icon(transform, Items.Icon(i), 44f, 417f, 64f);
			NativeWidgets.Label(transform, Items.Name(i), 125f, 426f, 300f, 70f, 22);
			NativeWidgets.Label(transform, L.Text("Target quantity:"), 446f, 394f, 170f, 34f, 19);
			InputField limit = NativeWidgets.Field(transform, orderLimit, 626f, 390f, 140f, 36f, number: true);
			Button infinity = NativeWidgets.Tab(transform, "∞", 787f, 390f, 46f, 36f, orderLimit == "0", delegate
			{
				limit.text = "0";
			});
			((Component)limit).gameObject.AddComponent<TraderFieldFocus>().Selected = delegate
			{
				if (int.TryParse(limit.text, out var result) && result == 0)
				{
					limit.text = "1";
				}
			};
			LimitMode();
			NativeWidgets.Label(transform, L.Text("0 — unlimited"), 626f, 430f, 220f, 27f, 15);
			NativeWidgets.Label(transform, L.Text("Coins per item:"), 446f, 475f, 180f, 34f, 19);
			InputField obj3 = NativeWidgets.Field(transform, orderPrice, 626f, 471f, 207f, 36f, number: true);
			Button save = null;
			save = NativeWidgets.Button(transform, L.Text("Save"), 862f, 379f, 194f, 38f, delegate
			{
				SendOrder(orderPaused);
			});
			((Selectable)save).interactable = Dirty();
			NativeWidgets.Mark((Selectable)(object)save, ((Selectable)save).interactable);
			((UnityEvent<string>)(object)limit.onValueChanged).AddListener((UnityAction<string>)delegate(string v)
			{
				orderLimit = v;
				LimitMode();
				((Selectable)save).interactable = Dirty();
				NativeWidgets.Mark((Selectable)(object)save, ((Selectable)save).interactable);
			});
			((UnityEvent<string>)(object)obj3.onValueChanged).AddListener((UnityAction<string>)delegate(string v)
			{
				orderPrice = v;
				((Selectable)save).interactable = Dirty();
				NativeWidgets.Mark((Selectable)(object)save, ((Selectable)save).interactable);
			});
			NativeWidgets.Icon(((Component)NativeWidgets.Button(transform, orderPaused ? L.Text("Resume") : L.Text("Pause"), 862f, 434f, 194f, 38f, delegate
			{
				orderPaused = !orderPaused;
				SendOrder(orderPaused);
			})).transform, TraderSkinAssets.Get(orderPaused ? "resume" : "pause"), 12f, 10f, 22f);
			Button obj4 = NativeWidgets.Button(transform, L.Text("Delete"), 862f, 489f, 194f, 36f, delegate
			{
				Request request = Request("removeOrder");
				request.Key = orderKey;
				orderKey = "";
				Submit(request);
			});
			((Selectable)obj4).interactable = view.Management.Orders.ContainsKey(orderKey);
			NativeWidgets.Icon(((Component)obj4).transform, TraderSkinAssets.Get("trash"), 12f, 10f, 22f);
			static bool Dirty()
			{
				if (view.Management.Orders.TryGetValue(orderKey, out var value) && !(value.Price.ToString() != orderPrice) && !(value.Limit.ToString() != orderLimit))
				{
					return value.Paused != orderPaused;
				}
				return true;
			}
			void LimitMode()
			{
				int result;
				bool flag = int.TryParse(limit.text, out result) && result == 0;
				NativeWidgets.Mark((Selectable)(object)infinity, flag);
				NativeWidgets.Mark((Selectable)(object)limit, !flag);
			}
			static void SendOrder(bool paused)
			{
				Check.That(int.TryParse(orderLimit, out var result) && result >= 0, L.Text("Enter a quantity from 0 to 2147483647"));
				Request request = Request("order");
				request.Key = orderKey;
				request.Price = Check.Positive(orderPrice);
				request.Limit = result;
				request.Paused = paused;
				Submit(request);
			}
		}

		private static void Catalog()
		{
			Transform transform = page.transform;
			InputField obj = NativeWidgets.Field(transform, catalogSearch, 24f, 120f, 1090f, 36f);
			obj.characterLimit = 100;
			((Component)obj.placeholder).GetComponent<Text>().text = L.Text("Items known to your character…");
			ScrollRect scroll;
			RectTransform content = NativeWidgets.Scroll(transform, 20f, 169f, 1126f, 366f, 366f, out scroll);
			((UnityEvent<string>)(object)obj.onValueChanged).AddListener((UnityAction<string>)delegate(string v)
			{
				catalogSearch = v;
				Rows();
			});
			Rows();
			void Rows()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				foreach (Transform item2 in (Transform)content)
				{
					((Component)item2).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)item2).gameObject);
				}
				List<Item> list = (catalog ?? Items.KnownItems()).Where((Item i) => Items.Name(i).IndexOf(catalogSearch, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
				content.sizeDelta = new Vector2(1104f, (float)Math.Max(366, (list.Count + 1) / 2 * 60));
				for (int num = 0; num < list.Count; num++)
				{
					Item item = list[num];
					float num2 = num % 2 * 548;
					float num3 = num / 2 * 60;
					NativeWidgets.Button((Transform)(object)content, "", num2 + 10f, num3 + 10f, 512f, 40f, delegate
					{
						SelectOrder(item.Prefab);
					});
					NativeWidgets.Icon((Transform)(object)content, Items.Icon(item), num2 + 8f, num3 + 5f, 44f);
					NativeWidgets.Label((Transform)(object)content, Items.Name(item), num2 + 65f, num3 + 11f, 456f, 34f, 21);
				}
				if (list.Count == 0)
				{
					NativeWidgets.Label((Transform)(object)content, L.Text("No known items"), 24f, 32f, 1000f, 44f, 23);
				}
			}
		}

		private static string HairName(string prefab)
		{
			if (!string.IsNullOrEmpty(prefab))
			{
				return Items.Name(Items.Factory(prefab));
			}
			return L.Text("None");
		}

		private static void Look()
		{
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			Transform body = page.transform;
			ScrollRect scroll;
			RectTransform p = NativeWidgets.Scroll(body, 12f, 66f, 296f, 452f, 536f, out scroll);
			NativeWidgets.Label((Transform)(object)p, L.Text("Name"), 12f, 2f, 255f, 25f, 20, heading: true);
			((UnityEvent<string>)(object)NativeWidgets.Field((Transform)(object)p, editLook.Name, 12f, 32f, 244f, 35f).onValueChanged).AddListener((UnityAction<string>)delegate(string v)
			{
				editLook.Name = v;
				RefreshSaveButtons();
			});
			NativeWidgets.Label((Transform)(object)p, L.Text("Gender"), 12f, 76f, 254f, 25f, 20, heading: true);
			NativeWidgets.Tab((Transform)(object)p, L.Text("Male"), 12f, 106f, 112f, 33f, editLook.Body == 0, delegate
			{
				editLook.Body = 0;
				BuildPage();
			});
			NativeWidgets.Tab((Transform)(object)p, L.Text("Female"), 144f, 106f, 112f, 33f, editLook.Body == 1, delegate
			{
				editLook.Body = 1;
				BuildPage();
			});
			PlayerCustomizaton val = ((IEnumerable<PlayerCustomizaton>)Resources.FindObjectsOfTypeAll<PlayerCustomizaton>()).FirstOrDefault((Func<PlayerCustomizaton, bool>)((PlayerCustomizaton c) => Object.op_Implicit((Object)(object)c.m_skinHue)));
			Color skin0 = (Color)(Object.op_Implicit((Object)(object)val) ? val.m_skinColor0 : new Color(0.45f, 0.25f, 0.15f));
			Color skin1 = (Color)(Object.op_Implicit((Object)(object)val) ? val.m_skinColor1 : new Color(1f, 0.87f, 0.72f));
			Color hair0 = (Color)(Object.op_Implicit((Object)(object)val) ? val.m_hairColor0 : new Color(1f, 0.87f, 0.5f));
			Color hair1 = (Color)(Object.op_Implicit((Object)(object)val) ? val.m_hairColor1 : new Color(0.3f, 0.18f, 0.1f));
			Color val2 = new Color(editLook.Skin[0], editLook.Skin[1], editLook.Skin[2]);
			Vector3 val3 = Vector4.op_Implicit(Color.op_Implicit(skin1 - skin0));
			float value = Mathf.Clamp01(Vector3.Dot(Vector4.op_Implicit(Color.op_Implicit(val2 - skin0)), val3) / Mathf.Max(0.0001f, ((Vector3)(ref val3)).sqrMagnitude));
			NativeWidgets.Label((Transform)(object)p, L.Text("Skin tone"), 12f, 154f, 254f, 27f, 20, heading: true);
			NativeWidgets.Slider((Transform)(object)p, value, 20f, 189f, 236f, delegate(float v)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				Color val7 = Color.Lerp(skin0, skin1, v);
				editLook.Skin = new float[3] { val7.r, val7.g, val7.b };
				ApplyPreview();
			});
			Selector(L.Text("Hairstyle"), 229f, beard: false);
			Selector(L.Text("Beard"), 307f, beard: true);
			float minLevel = (Object.op_Implicit((Object)(object)val) ? val.m_hairMinLevel : 0.05f);
			float maxLevel = (Object.op_Implicit((Object)(object)val) ? val.m_hairMaxLevel : 1f);
			Vector3 val4 = Vector4.op_Implicit(Color.op_Implicit(hair0));
			Vector3 val5 = Vector4.op_Implicit(Color.op_Implicit(hair1 - hair0));
			Vector3 val6 = Network.Vec(editLook.HairColor);
			float num = Vector3.Dot(val4, val4);
			float num2 = Vector3.Dot(val4, val5);
			float num3 = Vector3.Dot(val5, val5);
			float num4 = Vector3.Dot(val4, val6);
			float num5 = Vector3.Dot(val5, val6);
			float num6 = num * num3 - num2 * num2;
			float num7 = ((Mathf.Abs(num6) > 1E-06f) ? ((num4 * num3 - num5 * num2) / num6) : maxLevel);
			float tone = ((Mathf.Abs(num6 * num7) > 1E-06f) ? Mathf.Clamp01((num5 * num - num4 * num2) / (num6 * num7)) : 0.5f);
			float level = Mathf.InverseLerp(minLevel, maxLevel, num7);
			NativeWidgets.Label((Transform)(object)p, L.Text("Hair colour"), 12f, 390f, 254f, 26f, 20, heading: true);
			NativeWidgets.Slider((Transform)(object)p, tone, 20f, 420f, 236f, delegate(float v)
			{
				tone = v;
				HairColor();
			});
			NativeWidgets.Label((Transform)(object)p, L.Text("Colour depth"), 12f, 453f, 254f, 26f, 20, heading: true);
			NativeWidgets.Slider((Transform)(object)p, level, 20f, 484f, 236f, delegate(float v)
			{
				level = v;
				HairColor();
			});
			NativeWidgets.Line(body, 322f, 70f, 1f, 462f);
			NativeWidgets.Line(body, 602f, 70f, 1f, 462f);
			NativeWidgets.Icon(body, TraderSkinAssets.Get("pouch"), 610f, 64f, 36f);
			NativeWidgets.Label(body, L.Text("Trader equipment"), 658f, 66f, 486f, 30f, 23, heading: true);
			Bag bag = new Bag
			{
				Width = 5,
				Height = 1
			};
			for (int num8 = 0; num8 < Rules.Slots.Length; num8++)
			{
				NativeWidgets.Label(body, L.Text(Rules.Slots[num8]), 610f + (float)num8 * InventoryGui.instance.m_playerGrid.m_elementSpace, 102f, InventoryGui.instance.m_playerGrid.m_elementSpace, 30f, 14);
				if (view.Management.Equipment.TryGetValue(Rules.Slots[num8], out var value2))
				{
					Item item = Json.Copy(value2);
					item.Slot = num8;
					bag.Items.Add(item);
				}
			}
			AddGrid("equipment", bag, 610f, 134f, 536f, 88f);
			NativeWidgets.Icon(body, TraderSkinAssets.Get("backpack"), 610f, 230f, 36f);
			NativeWidgets.Label(body, L.Text("Your inventory"), 658f, 238f, 488f, 28f, 23, heading: true);
			AddGrid("player", Items.Snapshot(((Humanoid)Player.m_localPlayer).GetInventory()), 606f, 276f, 542f, 240f);
			NativeWidgets.Label(body, L.Text("RMB · equip / unequip"), 610f, 522f, 536f, 26f, 16);
			saveLook = NativeWidgets.Button(body, L.Text("Save"), 348f, 574f, 208f, 34f, delegate
			{
				if (!editLook.SameAs(view.Look))
				{
					Request request = Request("look");
					request.Look = Json.Copy(editLook);
					Submit(request);
				}
			});
			cancelLook = NativeWidgets.Button(body, L.Text("Cancel"), 596f, 574f, 208f, 34f, delegate
			{
				editLook = Json.Copy(view.Look);
				BuildPage();
			});
			RefreshSaveButtons();
			Safe(delegate
			{
				preview = new TraderPreview();
				preview.Create(body, 330f, 68f, 264f, 458f);
				ApplyPreview();
			});
			void HairColor()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				Color val7 = Color.Lerp(hair0, hair1, tone) * Mathf.Lerp(minLevel, maxLevel, level);
				editLook.HairColor = new float[3] { val7.r, val7.g, val7.b };
				ApplyPreview();
			}
			void Selector(string heading, float y, bool beard)
			{
				NativeWidgets.Label((Transform)(object)p, heading, 12f, y, 254f, 26f, 20, heading: true);
				Text label = NativeWidgets.Label((Transform)(object)p, HairName(beard ? editLook.Beard : editLook.Hair), 52f, y + 34f, 164f, 42f, 17);
				NativeWidgets.Button((Transform)(object)p, "‹", 12f, y + 32f, 34f, 34f, delegate
				{
					Change(-1);
				});
				NativeWidgets.Button((Transform)(object)p, "›", 222f, y + 32f, 34f, 34f, delegate
				{
					Change(1);
				});
				void Change(int step)
				{
					string[] array = new string[1] { "" }.Concat(beard ? WorldObjects.Beards : WorldObjects.Hairs).ToArray();
					int num9 = Array.IndexOf(array, beard ? editLook.Beard : editLook.Hair);
					string text = array[(num9 + step + array.Length) % array.Length];
					if (beard)
					{
						editLook.Beard = text;
					}
					else
					{
						editLook.Hair = text;
					}
					label.text = HairName(text);
					ApplyPreview();
				}
			}
		}

		private static void RefreshSaveButtons()
		{
			if (Object.op_Implicit((Object)(object)savePrices))
			{
				((Selectable)savePrices).interactable = priceEdits.Dirty;
				NativeWidgets.Mark((Selectable)(object)savePrices, priceEdits.Dirty);
			}
			bool flag = view != null && editLook != null && !editLook.SameAs(view.Look);
			if (Object.op_Implicit((Object)(object)saveLook))
			{
				((Selectable)saveLook).interactable = flag;
				NativeWidgets.Mark((Selectable)(object)saveLook, flag);
			}
			if (Object.op_Implicit((Object)(object)cancelLook))
			{
				((Selectable)cancelLook).interactable = flag;
			}
		}

		private static void ApplyPreview()
		{
			preview?.Apply(editLook, view.Management.Equipment);
			RefreshSaveButtons();
		}

		public static void Update()
		{
			RefreshInput();
			if (!Visible)
			{
				return;
			}
			Safe(delegate
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || ((Character)Player.m_localPlayer).IsDead())
				{
					Close();
				}
				else if (Input.GetKeyDown((KeyCode)27))
				{
					if (Object.op_Implicit((Object)(object)split) && ((Component)split).gameObject.activeSelf)
					{
						hideSplit.Invoke(InventoryGui.instance, null);
					}
					else if (IsDragging)
					{
						CancelDrag();
					}
					else
					{
						Close(send: true, gesture: true);
					}
				}
				else
				{
					RectTransform val = (RectTransform)root.transform;
					Transform parent = ((Transform)val).parent;
					RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
					if (Object.op_Implicit((Object)(object)val2))
					{
						Vector3 one = Vector3.one;
						Rect rect = val2.rect;
						float num = ((Rect)(ref rect)).width / 1760f;
						rect = val2.rect;
						((Transform)val).localScale = one * Mathf.Min(1f, Mathf.Min(num, ((Rect)(ref rect)).height / 1000f));
					}
					pageGroup.blocksRaycasts = !Network.Busy;
					if (inventoryDirty && !Network.Busy && !IsDragging && !((Component)split).gameObject.activeSelf)
					{
						BuildPage();
					}
					if (Time.unscaledTime >= nextGridUpdate)
					{
						nextGridUpdate = Time.unscaledTime + 0.05f;
						ItemData val3 = (IsDragging ? Drag<ItemData>("m_dragItem") : null);
						foreach (KeyValuePair<InventoryGrid, string> grid in grids)
						{
							grid.Key.UpdateInventory(inventories[grid.Value], (grid.Value == "player") ? Player.m_localPlayer : null, val3);
						}
					}
					if (IsDragging)
					{
						RaiseDrag();
						updateDrag.Invoke(InventoryGui.instance, null);
					}
					if (Object.op_Implicit((Object)(object)split) && ((Component)split).gameObject.activeSelf)
					{
						updateSplit.Invoke(InventoryGui.instance, null);
					}
					preview?.Tick();
					RefreshStatus();
				}
			});
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Update")]
	internal static class TraderInventoryUpdate
	{
		private static bool Prefix()
		{
			return !TraderUI.Visible;
		}
	}
	[HarmonyPatch(typeof(Player), "TakeInput")]
	internal static class TraderInput
	{
		private static void Postfix(ref bool __result)
		{
			if (Network.BlockInput)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(UIDragHandler), "OnEndDrag")]
	internal static class TraderMouseDrag
	{
		private static void Postfix(UIDragHandler __instance, PointerEventData __0)
		{
			TraderUI.Safe(delegate
			{
				TraderUI.MouseDragEnded(__instance, __0);
			});
		}
	}
}
namespace PlayerTraders.Core
{
	public static class BuildCost
	{
		public const string Default = "Coins:50";

		public static Dictionary<string, int> Parse(string text)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			Check.That(!string.IsNullOrWhiteSpace(text), "Building cost is not set");
			string[] array = text.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Trim().Split(':');
				Check.That(array2.Length == 2 && !string.IsNullOrWhiteSpace(array2[0]) && int.TryParse(array2[1], out var result) && result > 0 && result <= 10000, "Building cost: Prefab:quantity, for example Coins:50");
				string text2 = array2[0].Trim();
				Check.That(text2.Length <= 128 && !dictionary.ContainsKey(text2), "Duplicate or invalid building resource");
				dictionary.Add(text2, int.Parse(array2[1]));
			}
			Check.That(dictionary.Count <= 6, "A recipe can contain up to 6 resources");
			return dictionary;
		}
	}
	public static class CharacterAccess
	{
		public static long Require(long character)
		{
			Check.That(character != 0, "Your character is not ready. Try again in a few seconds.");
			return character;
		}

		public static void CheckPending(Transfer transfer, long character)
		{
			Require(character);
			if (transfer != null)
			{
				Check.That(transfer.ActorCharacter != 0, "The transaction has no character ID. Check the server journal; automatic delivery is blocked.");
				Check.That(transfer.ActorCharacter == character, "This account has an unfinished transaction for another character. Log in as that character to finish it.");
			}
		}
	}
	public sealed class DropPlan
	{
		public string Id;

		public string Owner;

		public float[] Position;

		public List<Item> Items = new List<Item>();

		public long Cash;

		public long OwnerCharacter;

		public static DropPlan From(Trader trader)
		{
			DropPlan dropPlan = new DropPlan
			{
				Id = trader.Id,
				Owner = trader.Owner,
				OwnerCharacter = trader.OwnerCharacter,
				Position = (float[])trader.Position.Clone(),
				Cash = trader.Cash
			};
			foreach (Item item2 in trader.Stock.Items.Concat(trader.Equipment.Values))
			{
				Item item = Json.Copy(item2);
				item.Equipped = false;
				dropPlan.Items.Add(item);
			}
			return dropPlan;
		}

		public IEnumerable<Item> Contents(Item coins)
		{
			foreach (Item item in Items)
			{
				yield return Json.Copy(item);
			}
			long left = Cash;
			while (left > 0)
			{
				int count = (int)Math.Min(left, coins.Max);
				yield return coins.Part(count);
				left -= count;
			}
		}

		public void Validate()
		{
			Check.That(Id != null && Id.Length == 32 && !string.IsNullOrEmpty(Owner) && Cash >= 0 && Position != null && Position.Length == 3 && Position.All((float p) => !float.IsNaN(p) && !float.IsInfinity(p)), "Invalid trader data");
			Check.That(Items.Count <= 105, "Data size limit exceeded");
			foreach (Item item in Items)
			{
				item.Validate();
				Check.That(!item.Equipped, "Invalid item data");
			}
		}
	}
	public sealed class GreetingGate
	{
		private readonly HashSet<int> nearby = new HashSet<int>();

		public bool HasNearby => nearby.Count > 0;

		public bool Enter(int player, float distance)
		{
			if (distance > 10f)
			{
				nearby.Remove(player);
				return false;
			}
			return nearby.Add(player);
		}

		public void Prune(ISet<int> present)
		{
			nearby.RemoveWhere((int id) => !present.Contains(id));
		}
	}
	public static class HairstyleChoices
	{
		public static string[] Current(IEnumerable<string> names)
		{
			return names.Where((string n) => !string.IsNullOrEmpty(n) && !n.Contains("_")).OrderBy<string, string>((string n) => n, StringComparer.Ordinal).ToArray();
		}
	}
	public static class InventoryNotice
	{
		public static bool ReceivedCheatedItem(Bag before, Bag after)
		{
			Dictionary<string, long> previous = (from i in before.Items
				where i.Cheated
				group i by i.Key).ToDictionary((IGrouping<string, Item> g) => g.Key, (IGrouping<string, Item> g) => ((IEnumerable<Item>)g).Sum((Func<Item, long>)((Item i) => i.Count)));
			long value;
			return (from i in after.Items
				where i.Cheated
				group i by i.Key).Any((IGrouping<string, Item> g) => ((IEnumerable<Item>)g).Sum((Func<Item, long>)((Item i) => i.Count)) > (previous.TryGetValue(g.Key, out value) ? value : 0));
		}
	}
	public static class Json
	{
		private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
		{
			TypeNameHandling = (TypeNameHandling)0,
			MaxDepth = 32,
			FloatParseHandling = (FloatParseHandling)0
		};

		public static string Write(object value)
		{
			return JsonConvert.SerializeObject(value, Settings);
		}

		public static T Read<T>(string value)
		{
			T val = JsonConvert.DeserializeObject<T>(value, Settings);
			if (val == null)
			{
				throw new InvalidOperationException("Empty data");
			}
			return val;
		}

		public static T Copy<T>(T value)
		{
			return Read<T>(Write(value));
		}

		public static string Hash(string value)
		{
			using SHA256 sHA = SHA256.Create();
			return BitConverter.ToString(sHA.ComputeHash(Encoding.UTF8.GetBytes(value))).Replace("-", "");
		}
	}
	public sealed class RuleException : Exception
	{
		public RuleException(string message)
			: base(message)
		{
		}
	}
	public static class Check
	{
		public static void That(bool condition, string text)
		{
			if (!condition)
			{
				throw new RuleException(text);
			}
		}

		public static int Positive(string text)
		{
			That(!string.IsNullOrEmpty(text) && text.All((char c) => c >= '0' && c <= '9') && int.TryParse(text, out var _), "Enter a positive whole number");
			int num = int.Parse(text);
			That(num > 0, "The number must be greater than zero");
			return num;
		}

		public static string Name(string value)
		{
			string text = new string((value ?? "").Where((char c) => !char.IsControl(c) && c != '<' && c != '>').ToArray()).Trim();
			That(text.Length > 0 && text.Length <= 32, "The name must contain 1 to 32 characters");
			return text;
		}
	}
	public sealed class Item
	{
		public string Prefab = "";

		public int Count = 1;

		public int Max = 1;

		public int Quality = 1;

		public int Variant;

		public int WorldLevel;

		public int Slot = -1;

		public float Durability;

		public long Crafter;

		public string CrafterName = "";

		public string EquipSlot = "";

		public bool PickedUp;

		public bool Cheated;

		public bool Equipped;

		public SortedDictionary<string, string> Data = new SortedDictionary<string, string>(StringComparer.Ordinal);

		[JsonIgnore]
		public string Key => Json.Hash(Json.Write(new { Prefab, Quality, Variant, WorldLevel, Durability, Crafter, CrafterName, PickedUp, Cheated, Data }));

		public Item Part(int count)
		{
			Item item = Json.Copy(this);
			item.Count = count;
			item.Slot = -1;
			item.Equipped = false;
			return item;
		}

		public void Validate()
		{
			Check.That(Prefab.Length > 0 && Prefab.Length <= 128 && Count > 0 && Max > 0 && Max <= 10000 && Count <= Max && Quality > 0 && Quality <= 100 && Variant >= 0 && !float.IsNaN(Durability) && !float.IsInfinity(Durability) && Durability >= 0f && Data != null && Data.Count <= 128 && Json.Write(Data).Length <= 32768 && CrafterName.Length <= 256, "Invalid item data");
		}
	}
	public sealed class Bag
	{
		public int Width = 10;

		public int Height = 10;

		public List<Item> Items = new List<Item>();

		[JsonIgnore]
		public int Capacity => checked(Width * Height);

		public void Validate()
		{
			Check.That(Width > 0 && Width <= 16 && Height > 0 && Height <= 16 && Items != null && Items.Count <= Capacity, "Invalid inventory");
			HashSet<int> hashSet = new HashSet<int>();
			foreach (Item item in Items)
			{
				item.Validate();
				Check.That(item.Slot >= 0 && item.Slot < Capacity && hashSet.Add(item.Slot), "Duplicate inventory slot");
			}
		}

		public Item At(int slot)
		{
			return Items.SingleOrDefault((Item i) => i.Slot == slot) ?? throw new RuleException("The item has already been moved");
		}

		public long Count(string key)
		{
			return Items.Where((Item i) => i.Key == key).Sum((Func<Item, long>)((Item i) => i.Count));
		}

		public Item Take(int slot, int count)
		{
			Item item = At(slot);
			Check.That(!item.Equipped, "Unequip the item first");
			Check.That(count > 0 && count <= item.Count, "Not enough items");
			Item result = item.Part(count);
			item.Count -= count;
			if (item.Count == 0)
			{
				Items.Remove(item);
			}
			return result;
		}

		public void Add(Item item)
		{
			item.Validate();
			int num = item.Count;
			foreach (Item item3 in from i in Items
				where !i.Equipped && i.Key == item.Key
				orderby i.Slot
				select i)
			{
				int num2 = Math.Min(num, Math.Max(0, item3.Max - item3.Count));
				item3.Count += num2;
				num -= num2;
				if (num == 0)
				{
					return;
				}
			}
			while (num > 0)
			{
				int num3 = (from s in Enumerable.Range(0, Capacity)
					where Items.All((Item i) => i.Slot != s)
					select s).DefaultIfEmpty(-1).First();
				Check.That(num3 >= 0, "Not enough space");
				Item item2 = item.Part(Math.Min(num, item.Max));
				item2.Slot = num3;
				Items.Add(item2);
				num -= item2.Count;
			}
		}

		public List<Item> TakeKey(string key, long count)
		{
			Check.That(count > 0 && Count(key) >= count, "Out of stock");
			List<Item> list = new List<Item>();
			foreach (Item item in (from i in Items
				where i.Key == key
				orderby i.Slot
				select i).ToList())
			{
				int num = (int)Math.Min(count, item.Count);
				list.Add(Take(item.Slot, num));
				count -= num;
				if (count == 0L)
				{
					break;
				}
			}
			return list;
		}

		public void Pay(int amount)
		{
			Check.That(amount > 0 && Items.Where((Item i) => i.Prefab == "Coins" && !i.Equipped).Sum((Func<Item, long>)((Item i) => i.Count)) >= amount, "Not enough coins");
			foreach (Item item in (from i in Items
				where i.Prefab == "Coins" && !i.Equipped
				orderby i.Slot
				select i).ToList())
			{
				int num = Math.Min(amount, item.Count);
				Take(item.Slot, num);
				amount -= num;
				if (amount == 0)
				{
					break;
				}
			}
		}
	}
	public sealed class Offer
	{
		public Item Sample;

		public int Price = 1;
	}
	public sealed class Look
	{
		public string Name = "Bjorn";

		public string Hair = "Hair1";

		public string Beard = "Beard1";

		public int Body;

		public float[] Skin = new float[3] { 1f, 0.8f, 0.65f };

		public float[] HairColor = new float[3] { 0.25f, 0.15f, 0.08f };

		public bool SameAs(Look other)
		{
			if (other != null && Name.Trim() == other.Name.Trim() && Body == other.Body && Hair == other.Hair && Beard == other.Beard && SameColor(Skin, other.Skin))
			{
				return SameColor(HairColor, other.HairColor);
			}
			return false;
		}

		private static bool SameColor(float[] a, float[] b)
		{
			if (a != null && b != null && a.Length == b.Length)
			{
				return a.Zip(b, (float x, float y) => Math.Abs(x - y) <= 1E-05f).All((bool equal) => equal);
			}
			return false;
		}

		public void Validate()
		{
			Name = Check.Name(Name);
			Check.That(Body == 0 || Body == 1, "Unknown body type");
			float[][] array = new float[2][] { Skin, HairColor };
			foreach (float[] array2 in array)
			{
				Check.That(array2 != null && array2.Length == 3 && array2.All((float x) => !float.IsNaN(x) && x >= 0f && x <= 1f), "Invalid colour");
			}
			Check.That(Hair.Length <= 64 && Beard.Length <= 64, "Invalid appearance");
		}
	}
	public enum PlaceState
	{
		Placed
	}
	public sealed class Trader
	{
		public string Id = Guid.NewGuid().ToString("N");

		public string Owner = "";

		public string OwnerName = "";

		public long World;

		public long Revision;

		public long OwnerCharacter;

		public long OfferRevision;

		public PlaceState Place;

		public float[] Position = new float[3];

		public float Yaw;

		public Bag Stock = new Bag();

		public Dictionary<string, BuyOrder> Orders = new Dictionary<string, BuyOrder>();

		public Dictionary<string, Offer> Offers = new Dictionary<string, Offer>();

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

		public long Cash;

		public Look Look = new Look();

		public bool IsOwner(string account, long character)
		{
			if (Owner == account)
			{
				return OwnerCharacter == character;
			}
			return false;
		}

		public void Validate(long world)
		{
			Check.That(Id.Length == 32 && World == world && Owner.Length > 0 && Owner.Length <= 256 && Revision >= 0 && OfferRevision >= 0 && Place == PlaceState.Placed && Cash >= 0 && Position != null && Position.Length == 3 && Position.All((float x) => !float.IsNaN(x) && !float.IsInfinity(x)) && !float.IsNaN(Yaw) && !float.IsInfinity(Yaw), "Invalid trader data");
			Check.That(Stock.Width == 10 && Stock.Height == 10, "The warehouse must have 100 slots");
			Stock.Validate();
			Look.Validate();
			Check.That(Orders != null && Orders.Count <= 1000, "Data size limit exceeded");
			foreach (KeyValuePair<string, BuyOrder> order in Orders)
			{
				order.Value.Validate();
				Check.That(order.Key == order.Value.Sample.Prefab, "Invalid price");
			}
			Check.That(Offers.Count <= 10000 && Equipment.Count <= 5, "Data size limit exceeded");
			foreach (KeyValuePair<string, Item> item in Equipment)
			{
				item.Value.Validate();
				Check.That(Rules.Slots.Contains(item.Key) && item.Key == item.Value.EquipSlot && item.Value.Count == 1, "Invalid equipment");
			}
			foreach (KeyValuePair<string, Offer> offer in Offers)
			{
				offer.Value.Sample.Validate();
				Check.That(offer.Key == offer.Value.Sample.Key && offer.Value.Price > 0 && offer.Value.Sample.Prefab != "Coins", "Invalid price");
			}
		}
	}
	public sealed class Request
	{
		public string Action = "";

		public string Trader = "";

		public string Session = "";

		public string Id = "";

		public string Key = "";

		public string Target = "stock";

		public long Revision;

		public long Sequence;

		public int Slot;

		public int Count;

		public int Price;

		public string Source = "player";

		public int TargetSlot = -1;

		public Bag Inventory;

		public Look Look;

		public float[] Position;

		public float Yaw;

		public Dictionary<string, int> Prices;

		public int Limit;

		public bool Paused;
	}
	public sealed class Transfer
	{
		public string Id;

		public string Actor;

		public long Sequence;

		public Trader Before;

		public Trader After;

		public Bag PlayerBefore;

		public Bag PlayerAfter;

		public string Phase = "prepared";

		public string Action;

		public long ActorCharacter;
	}
	public sealed class Receipt
	{
		public long Sequence;

		public string Id = "";
	}
	public sealed class Registry
	{
		public int Schema = 1;

		public long World;

		public Dictionary<string, Trader> Traders = new Dictionary<string, Trader>();

		public Dictionary<string, Transfer> Pending = new Dictionary<string, Transfer>();

		public Dictionary<string, Receipt> Receipts = new Dictionary<string, Receipt>();

		public Dictionary<string, DropPlan> Drops = new Dictionary<string, DropPlan>();

		public void Validate(long world)
		{
			Check.That(Schema == 1 && World == world, "Unsupported format or different world");
			foreach (KeyValuePair<string, Trader> trader in Traders)
			{
				Check.That(trader.Key == trader.Value.Id, "Invalid ID");
				trader.Value.Validate(World);
			}
			foreach (KeyValuePair<string, DropPlan> drop in Drops)
			{
				Check.That(drop.Key == drop.Value.Id && !Traders.ContainsKey(drop.Key), "Invalid ID");
				drop.Value.Validate();
			}
			foreach (Transfer value in Pending.Values)
			{
				value.After.Validate(World);
				value.PlayerBefore.Validate();
				value.PlayerAfter.Validate();
				Check.That(value.Phase == "prepared" || value.Phase == "committed", "Corrupted journal");
			}
		}
	}
	public static class MoveGuard
	{
		public static void Validate(Bag player, Bag stock, Request r)
		{
			Check.That((r.Source == "player" || r.Source == "stock") && (r.Target == "player" || r.Target == "stock"), "Choose where to return the clothing");
			Bag obj = ((r.Source == "player") ? player : stock);
			Bag bag = ((r.Target == "player") ? player : stock);
			Item item = obj.At(r.Slot);
			Check.That(!item.Equipped, "Unequip the item first");
			Check.That(r.Count > 0 && r.Count <= item.Count, "Not enough items");
			Check.That(r.TargetSlot >= -1 && r.TargetSlot < bag.Capacity, "Duplicate inventory slot");
			Item item2 = bag.Items.FirstOrDefault((Item i) => i.Slot == r.TargetSlot);
			Check.That(item2 == null || !item2.Equipped, "Unequip the item first");
		}

		public static void Verify(Bag beforePlayer, Bag beforeStock, Bag player, Bag stock)
		{
			player.Validate();
			stock.Validate();
			Check.That(player.Width == beforePlayer.Width && player.Height == beforePlayer.Height && stock.Width == beforeStock.Width && stock.Height == beforeStock.Height, "Invalid inventory");
			Check.That(Total(beforePlayer, beforeStock) == Total(player, stock), "The move changed item properties or quantities");
			Check.That(Json.Write(from i in beforePlayer.Items
				where i.Equipped
				orderby i.Slot
				select i) == Json.Write(from i in player.Items
				where i.Equipped
				orderby i.Slot
				select i), "Player equipment changed");
			static string Total(Bag a, Bag b)
			{
				return Json.Write(from i in a.Items.Concat(b.Items)
					group i by i.Key into g
					orderby g.Key
					select new
					{
						Key = g.Key,
						Count = ((IEnumerable<Item>)g).Sum((Func<Item, long>)((Item i) => i.Count))
					});
			}
		}
	}
	public static class OfferNews
	{
		private static Dictionary<string, int> Offers(Trader trader)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			if (trader == null)
			{
				return dictionary;
			}
			foreach (SaleRow item in from r in SaleRows.From(trader)
				where r.Sample.Prefab != "Coins"
				select r)
			{
				dictionary["sale:" + item.Key] = item.Price;
			}
			foreach (KeyValuePair<string, BuyOrder> item2 in trader.Orders.Where((KeyValuePair<string, BuyOrder> p) => !p.Value.Paused && p.Value.Remaining > 0))
			{
				dictionary["buy:" + item2.Key] = item2.Value.Price;
			}
			return dictionary;
		}

		public static bool HasNew(Trader before, Trader after)
		{
			Dictionary<string, int> old = Offers(before);
			int value;
			return Offers(after).Any((KeyValuePair<string, int> p) => !old.TryGetValue(p.Key, out value) || value != p.Value);
		}

		public static long Version(Trader trader)
		{
			if (!trader.Stock.Items.Any((Item i) => i.Slot < 50 && i.Prefab != "Coins") && !trader.Orders.Values.Any((BuyOrder o) => !o.Paused && o.Remaining > 0))
			{
				return 0L;
			}
			return Math.Max(trader.OfferRevision, 1L);
		}

		public static long Next(Trader before, Trader after)
		{
			if (!HasNew(before, after))
			{
				return before?.OfferRevision ?? 0;
			}
			return checked(((before == null) ? 0 : Math.Max(before.OfferRevision, Version(before))) + 1);
		}

		public static string Key(long world, string trader)
		{
			return "PT.seen." + world.ToString(CultureInfo.InvariantCulture) + "." + trader;
		}

		public static bool Unread(long version, string seen)
		{
			if (version > 0)
			{
				if (long.TryParse(seen, NumberStyles.None, CultureInfo.InvariantCulture, out var result))
				{
					return result < version;
				}
				return true;
			}
			return false;
		}

		public static string Remember(long viewed, string previous)
		{
			long.TryParse(previous, NumberStyles.None, CultureInfo.InvariantCulture, out var result);
			return Math.Max(result, viewed).ToString(CultureInfo.InvariantCulture);
		}
	}
	public sealed class PriceEdits
	{
		private readonly Dictionary<string, int> saved = new Dictionary<string, int>();

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

		public bool Dirty => saved.Any((KeyValuePair<string, int> p) => !Equal(text[p.Key], p.Value));

		public void Sync(IEnumerable<SaleRow> rows)
		{
			Dictionary<string, SaleRow> current = rows.Where((SaleRow r) => r.Sample.Prefab != "Coins").ToDictionary((SaleRow r) => r.Key);
			string[] array = saved.Keys.Where((string k) => !current.ContainsKey(k)).ToArray();
			foreach (string key in array)
			{
				saved.Remove(key);
				text.Remove(key);
			}
			foreach (SaleRow value2 in current.Values)
			{
				if (!saved.TryGetValue(value2.Key, out var value) || Equal(text[value2.Key], value) || Equal(text[value2.Key], value2.Price))
				{
					text[value2.Key] = value2.Price.ToString();
				}
				saved[value2.Key] = value2.Price;
			}
		}

		private static bool Equal(string value, int price)
		{
			if (int.TryParse(value, out var result))
			{
				return result == price;
			}
			return false;
		}

		public string Get(string key)
		{
			return text[key];
		}

		public void Set(string key, string value)
		{
			Check.That(saved.ContainsKey(key), "This item is no longer for sale");
			text[key] = value;
		}

		public Dictionary<string, int> Changes()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (KeyValuePair<string, int> item in saved)
			{
				int num = Check.Positive(text[item.Key]);
				if (num != item.Value)
				{
					dictionary.Add(item.Key, num);
				}
			}
			return dictionary;
		}
	}
	public sealed class BuyOrder
	{
		public Item Sample;

		public int Price = 1;

		public int Limit;

		public long Received;

		public bool Paused;

		[JsonIgnore]
		public long Remaining
		{
			get
			{
				if (Limit != 0)
				{
					return Math.Max(0L, Limit - Received);
				}
				return long.MaxValue;
			}
		}

		public void Validate()
		{
			Check.That(Sample != null, "No purchase item selected");
			Sample.Validate();
			Check.That(Sample.Prefab != "Coins" && Price > 0 && Limit >= 0 && Received >= 0, "Invalid buy order");
		}
	}
	public static class Warehouses
	{
		public static Bag Part(Bag stock, bool purchased)
		{
			int offset = (purchased ? 50 : 0);
			return new Bag
			{
				Width = 5,
				Height = 10,
				Items = stock.Items.Where((Item i) => i.Slot >= offset && i.Slot < offset + 50).Select(delegate(Item i)
				{
					Item item = Json.Copy(i);
					item.Slot -= offset;
					return item;
				}).ToList()
			};
		}

		public static void Put(Bag stock, Bag part, bool purchased)
		{
			part.Validate();
			Check.That(part.Width == 5 && part.Height == 10, "Invalid inventory");
			int offset = (purchased ? 50 : 0);
			stock.Items.RemoveAll((Item i) => i.Slot >= offset && i.Slot < offset + 50);
			stock.Items.AddRange(part.Items.Select(delegate(Item i)
			{
				Item item = Json.Copy(i);
				item.Slot += offset;
				return item;
			}));
			stock.Items = stock.Items.OrderBy((Item i) => i.Slot).ToList();
		}

		public static void Move(Bag player, Bag stock, Request request, Action<Bag, Bag, Request, bool> native)
		{
			Check.That(new string[3] { "player", "stock", "purchased" }.Contains(request.Source) && new string[3] { "player", "stock", "purchased" }.Contains(request.Target), "Choose where to return the clothing");
			Check.That(request.Target != "purchased" || request.Source == "purchased", "Purchased stock can only be filled by purchases");
			Bag sale = Part(stock, purchased: false);
			Bag bought = Part(stock, purchased: true);
			Bag bag = Get(request.Source);
			Bag bag2 = Get(request.Target);
			Item item = bag.At(request.Slot);
			Item item2 = bag2.Items.FirstOrDefault((Item i) => i.Slot == request.TargetSlot);
			Check.That(request.Source != "purchased" || request.Target == "purchased" || item2 == null || item2.Key == item.Key, "Move to an empty slot: swapping with purchased stock is not allowed");
			Request request2 = Json.Copy(request);
			request2.Source = "player";
			request2.Target = ((bag == bag2) ? "player" : "stock");
			Bag bag3 = ((bag == bag2) ? new Bag
			{
				Width = 5,
				Height = 10
			} : bag2);
			MoveGuard.Validate(bag, bag3, request2);
			Check.That(native != null, "Item movement is unavailable");
			Bag beforePlayer = Json.Copy(player);
			Bag beforeStock = Json.Copy(stock);
			native(bag, bag3, request2, request.Target != "player");
			Put(stock, sale, purchased: false);
			Put(stock, bought, purchased: true);
			MoveGuard.Verify(beforePlayer, beforeStock, player, stock);
			Bag Get(string name)
			{
				if (!(name == "player"))
				{
					if (!(name == "stock"))
					{
						return bought;
					}
					return sale;
				}
				return player;
			}
		}
	}
	public enum RecoveryStep
	{
		Ready,
		Apply,
		Acknowledge,
		Abort
	}
	public static class Recovery
	{
		public static RecoveryStep Decide(string phase, bool characterReceipt, bool inventoryMatchesBefore)
		{
			Check.That(phase == "prepared" || phase == "committed", "Unknown transaction stage");
			if (characterReceipt)
			{
				Check.That(phase == "committed", "The character receipt does not match the host journal");
				return RecoveryStep.Acknowledge;
			}
			if (phase == "prepared")
			{
				if (!inventoryMatchesBefore)
				{
					return RecoveryStep.Abort;
				}
				return RecoveryStep.Ready;
			}
			Check.That(inventoryMatchesBefore, "Inventory does not match the journal; duplicate delivery blocked. Saved data needs checking.");
			return RecoveryStep.Apply;
		}
	}
	public sealed class Rules
	{
		public static readonly string[] Slots = new string[5] { "Голова", "Торс", "Ноги", "Плечи", "Аксессуар" };

		private readonly Func<string, Item> factory;

		public Action<Bag, Bag, Request, bool> NativeMove;

		public Action<Bag, Item, int> NativePlace;

		public Dictionary<string, int> ConstructionCost = BuildCost.Parse("Coins:50");

		public Rules(Func<string, Item> factory)
		{
			this.factory = factory;
		}

		public Transfer Prepare(Registry registry, string actor, string actorName, Request r, Look initial, long character = 0L)
		{
			Check.That(r.Id != null && Guid.TryParseExact(r.Id, "N", out var _) && r.Sequence > 0, "Invalid transaction number");
			Check.That(!registry.Pending.ContainsKey(actor), "The previous transaction needs recovery");
			Receipt value;
			long num = (registry.Receipts.TryGetValue(actor, out value) ? value.Sequence : 0);
			checked
			{
				Check.That(r.Sequence == num + 1, "Duplicate or outdated transaction");
				Check.That(r.Inventory != null, "Inventory confirmation missing");
				r.Inventory.Validate();
				Bag bag = Json.Copy(r.Inventory);
				Trader before = null;
				Trader trader;
				if (r.Action == "create")
				{
					initial.Validate();
					trader = new Trader
					{
						World = registry.World,
						Owner = actor,
						OwnerCharacter = character,
						OwnerName = Check.Name(actorName),
						Look = initial,
						Position = r.Position,
						Yaw = r.Yaw
					};
					foreach (KeyValuePair<string, int> item3 in ConstructionCost)
					{
						PayMaterial(bag, item3.Key, item3.Value);
					}
				}
				else
				{
					Check.That(registry.Traders.TryGetValue(r.Trader, out before), "Trader not found");
					Check.That(!registry.Pending.Values.Any((Transfer p) => p.After.Id == before.Id), "The trader has an unfinished transaction");
					Check.That(before.Revision == r.Revision, "Data changed: open the trader again");
					Check.That(r.Action == "buy" || r.Action == "sell" || before.IsOwner(actor, character), "Only the owner can do this");
					Check.That(before.Place == PlaceState.Placed, "The trader is not placed in the world");
					trader = Json.Copy(before);
					switch (r.Action)
					{
					case "move":
						Warehouses.Move(bag, trader.Stock, r, NativeMove);
						break;
					case "prices":
					{
						Check.That(r.Prices != null && r.Prices.Count > 0 && r.Prices.Count <= 100, "The unit price must be a positive whole number");
						Dictionary<string, SaleRow> dictionary = SaleRows.From(trader).ToDictionary((SaleRow row) => row.Key);
						foreach (KeyValuePair<string, int> price in r.Prices)
						{
							Check.That(dictionary.TryGetValue(price.Key, out var value6) && value6.Sample.Prefab != "Coins", "This item is no longer for sale");
							Check.That(price.Value > 0, "The unit price must be a positive whole number");
							trader.Offers[price.Key] = new Offer
							{
								Sample = value6.Sample.Part(1),
								Price = price.Value
							};
						}
						break;
					}
					case "buy":
					{
						SaleRow saleRow = SaleRows.From(trader).FirstOrDefault((SaleRow row) => row.Key == r.Key && row.Sample.Prefab != "Coins");
						Check.That(saleRow != null, "This item is no longer for sale");
						Check.That(r.Count > 0, "Choose an item quantity");
						long num5 = r.Count;
						long num6 = unchecked((long)r.Count) * unchecked((long)saleRow.Price);
						Check.That(num6 <= int.MaxValue, "The total is too large; choose a smaller quantity");
						Bag bag4 = Warehouses.Part(trader.Stock, purchased: false);
						Check.That(bag4.Count(r.Key) >= num5, "Out of stock");
						bag.Pay(unchecked((int)num6));
						foreach (Item item4 in bag4.TakeKey(r.Key, num5))
						{
							bag.Add(item4);
						}
						Warehouses.Put(trader.Stock, bag4, purchased: false);
						trader.Cash += num6;
						break;
					}
					case "order":
					{
						Item item = factory(r.Key);
						item.Slot = -1;
						BuyOrder value3;
						BuyOrder buyOrder = new BuyOrder
						{
							Sample = item,
							Price = r.Price,
							Limit = r.Limit,
							Paused = r.Paused,
							Received = (trader.Orders.TryGetValue(r.Key, out value3) ? value3.Received : 0)
						};
						buyOrder.Validate();
						trader.Orders[r.Key] = buyOrder;
						break;
					}
					case "removeOrder":
						Check.That(trader.Orders.Remove(r.Key), "The order has already been removed");
						break;
					case "sell":
					{
						Check.That(trader.Orders.TryGetValue(r.Key, out var value5) && !value5.Paused, "Purchasing is paused");
						Check.That(r.Count > 0 && r.Count <= value5.Remaining, "Quantity exceeds the remaining order");
						long num2 = unchecked((long)r.Count) * unchecked((long)value5.Price);
						Check.That(num2 <= int.MaxValue && trader.Cash >= num2, "Not enough coins in the till");
						List<Item> list = (from i in bag.Items
							where i.Prefab == r.Key && !i.Equipped
							orderby i.Slot
							select i).ToList();
						Check.That(((IEnumerable<Item>)list).Sum((Func<Item, long>)((Item i) => i.Count)) >= r.Count, "You do not have enough items");
						Bag bag3 = Warehouses.Part(trader.Stock, purchased: true);
						int num3 = r.Count;
						unchecked
						{
							foreach (Item item5 in list)
							{
								int num4 = Math.Min(num3, item5.Count);
								bag3.Add(bag.Take(item5.Slot, num4));
								num3 -= num4;
								if (num3 == 0)
								{
									break;
								}
							}
							AddMany(bag, factory("Coins"), (int)num2);
							Warehouses.Put(trader.Stock, bag3, purchased: true);
							trader.Cash -= num2;
						}
						value5.Received += r.Count;
						break;
					}
					case "fund":
						bag.Pay(r.Count);
						trader.Cash += r.Count;
						break;
					case "cash":
						Check.That(r.Count > 0 && trader.Cash >= r.Count, "Not enough coins in the till");
						AddMany(bag, factory("Coins"), r.Count);
						unchecked
						{
							trader.Cash -= r.Count;
							break;
						}
					case "look":
						Check.That(r.Look != null, "Appearance is not set");
						r.Look.Validate();
						trader.Look = Json.Copy(r.Look);
						break;
					case "equipPlayer":
					{
						Check.That(r.Target == "player", "Choose where to return the clothing");
						Item item2 = bag.Take(r.Slot, 1);
						Check.That(Slots.Contains(item2.EquipSlot), "Only head, chest, legs, shoulders and accessory slots are supported");
						Check.That(string.IsNullOrEmpty(r.Key) || r.Key == item2.EquipSlot, "Only head, chest, legs, shoulders and accessory slots are supported");
						if (trader.Equipment.TryGetValue(item2.EquipSlot, out var value4))
						{
							bag.Add(value4);
						}
						trader.Equipment[item2.EquipSlot] = item2;
						break;
					}
					case "unequip":
					{
						Check.That(r.Target == "player", "Choose where to return the clothing");
						Check.That(trader.Equipment.TryGetValue(r.Key, out var value2), "The slot is empty");
						Bag bag2 = bag;
						if (r.TargetSlot < 0)
						{
							bag2.Add(value2);
						}
						else
						{
							Check.That(NativePlace != null, "Item movement is unavailable");
							NativePlace(bag2, value2, r.TargetSlot);
						}
						trader.Equipment.Remove(r.Key);
						break;
					}
					default:
						throw new RuleException("Unknown action");
					}
				}
				trader.OfferRevision = OfferNews.Next(before, trader);
				trader.Revision++;
				trader.Validate(registry.World);
				bag.Validate();
				return new Transfer
				{
					Id = r.Id,
					Actor = actor,
					ActorCharacter = character,
					Sequence = r.Sequence,
					Before = before,
					After = trader,
					PlayerBefore = Json.Copy(r.Inventory),
					PlayerAfter = bag,
					Action = r.Action
				};
			}
		}

		private static void AddMany(Bag bag, Item sample, int count)
		{
			while (count > 0)
			{
				int num = Math.Min(count, sample.Max);
				bag.Add(sample.Part(num));
				count -= num;
			}
		}

		private static void PayMaterial(Bag bag, string prefab, int count)
		{
			Check.That(count >= 0 && bag.Items.Where((Item i) => i.Prefab == prefab && !i.Equipped).Sum((Func<Item, long>)((Item i) => i.Count)) >= count, "Not enough materials to create a trader");
			foreach (Item item in bag.Items.Where((Item i) => i.Prefab == prefab && !i.Equipped).ToList())
			{
				if (count == 0)
				{
					break;
				}
				int num = Math.Min(count, item.Count);
				bag.Take(item.Slot, num);
				count -= num;
			}
		}
	}
	public sealed class Sessions
	{
		private sealed class Lease
		{
			public string Actor;

			public string Token;

			public double Last;
		}

		private readonly Dictionary<string, Lease> leases = new Dictionary<string, Lease>();

		public string Open(string trader, string actor, double now)
		{
			Expire(now);
			if (leases.TryGetValue(trader, out var value))
			{
				PlayerTraders.Core.Check.That(value.Actor == actor, "The trader is busy");
				value.Last = now;
				return value.Token;
			}
			PlayerTraders.Core.Check.That(!leases.Values.Any((Lease x) => x.Actor == actor), "Close the other trader first");
			Lease lease = new Lease
			{
				Actor = actor,
				Token = Guid.NewGuid().ToString("N"),
				Last = now
			};
			leases.Add(trader, lease);
			return lease.Token;
		}

		public void Check(string trader, string actor, string token, double now)
		{
			Expire(now);
			PlayerTraders.Core.Check.That(leases.TryGetValue(trader, out var value) && value.Actor == actor && value.Token == token, "Session ended: open the trader again");
			value.Last = now;
		}

		public void Close(string trader, string actor)
		{
			if (leases.TryGetValue(trader, out var value) && value.Actor == actor)
			{
				leases.Remove(trader);
			}
		}

		public void Expire(double now)
		{
			foreach (string item in (from p in leases
				where now - p.Value.Last > 15.0
				select p.Key).ToList())
			{
				leases.Remove(item);
			}
		}

		public void Prune(Func<string, string, bool> alive)
		{
			foreach (string item in (from p in leases
				where !alive(p.Key, p.Value.Actor)
				select p.Key).ToList())
			{
				leases.Remove(item);
			}
		}
	}
	public sealed class SaleRow
	{
		public string Key;

		public Item Sample;

		public int Slot;

		public int Price;

		public long Quantity;
	}
	public static class SaleRows
	{
		public static List<SaleRow> From(Trader trader)
		{
			return (from r in (from i in trader.Stock.Items
					where i.Slot < 50
					group i by i.Key).Select(delegate(IGrouping<string, Item> @group)
				{
					Item item = @group.OrderBy((Item i) => i.Slot).First();
					trader.Offers.TryGetValue(@group.Key, out var value);
					return new SaleRow
					{
						Key = @group.Key,
						Sample = item,
						Slot = item.Slot,
						Quantity = ((IEnumerable<Item>)@group).Sum((Func<Item, long>)((Item i) => i.Count)),
						Price = (value?.Price ?? 1)
					};
				})
				orderby (r.Slot >= 0) ? r.Slot : int.MaxValue, r.Key
				select r).ToList();
		}
	}
	public sealed class ShopView
	{
		public string Id;

		public string OwnerName;

		public bool IsOwner;

		public long Revision;

		public long OfferRevision;

		public Look Look;

		public Trader Management;

		public List<BuyingListing> Buying = new List<BuyingListing>();

		public List<Listing> Listings = new List<Listing>();

		public static ShopView For(Trader trader, string account, long character)
		{
			bool flag = trader.IsOwner(account, character);
			return new ShopView
			{
				Id = trader.Id,
				OwnerName = trader.OwnerName,
				IsOwner = flag,
				Revision = trader.Revision,
				OfferRevision = OfferNews.Version(trader),
				Look = trader.Look,
				Management = (flag ? trader : null),
				Buying = (from p in trader.Orders
					where !p.Value.Paused && p.Value.Remaining > 0
					select new BuyingListing
					{
						Key = p.Key,
						Sample = p.Value.Sample,
						Price = p.Value.Price,
						Remaining = ((p.Value.Limit == 0) ? (-1) : p.Value.Remaining),
						Affordable = Math.Min(p.Value.Remaining, trader.Cash / p.Value.Price)
					}).ToList(),
				Listings = (from row in SaleRows.From(trader)
					where row.Sample.Prefab != "Coins"
					select new Listing
					{
						Key = row.Key,
						Sample = row.Sample,
						Price = row.Price,
						Quantity = row.Quantity
					}).ToList()
			};
		}
	}
	public sealed class Listing
	{
		public string Key;

		public Item Sample;

		public int Price;

		public long Quantity;
	}
	public sealed class BuyingListing
	{
		public string Key;

		public Item Sample;

		public int Price;

		public long Remaining;

		public long Affordable;
	}
	public sealed class ShopVisit
	{
		private string trader;

		private bool traded;

		public void Open(string id)
		{
			if (!(trader == id))
			{
				trader = id;
				traded = false;
			}
		}

		public void Completed(string id, string action)
		{
			if (trader != null && trader == id && (action == "buy" || action == "sell"))
			{
				traded = true;
			}
		}

		public string Close(bool byUser)
		{
			string result = ((!byUser || trader == null) ? null : (traded ? "thumbsup" : "shrug"));
			trader = null;
			traded = false;
			return result;
		}
	}
	public sealed class Store
	{
		private sealed class Envelope
		{
			public int Schema = 1;

			public string Hash;

			public string Payload;
		}

		public readonly string Path;

		public Store(string path)
		{
			Path = path;
		}

		public T Load<T>()
		{
			Check.That(new FileInfo(Path).Length <= 67108864, "The data file is too large");
			Envelope envelope = Json.Read<Envelope>(File.ReadAllText(Path, Encoding.UTF8));
			Check.That(envelope.Schema == 1 && envelope.Payload != null && envelope.Hash == Json.Hash(envelope.Payload), "Corrupted data; the original is preserved and operations are blocked");
			return Json.Read<T>(envelope.Payload);
		}

		public void Save<T>(T data)
		{
			string text = Json.Write(data);
			Check.That(Encoding.UTF8.GetByteCount(text) <= 62914560, "Storage is full: operations stopped");
			Directory.CreateDirectory(System.IO.Path.GetDirectoryName(Path));
			byte[] bytes = Encoding.UTF8.GetBytes(Json.Write(new Envelope
			{
				Payload = text,
				Hash = Json.Hash(text)
			}));
			string text2 = Path + ".tmp";
			using (FileStream fileStream = new FileStream(text2, FileMode.Create, FileAccess.Write, FileShare.None))
			{
				fileStream.Write(bytes, 0, bytes.Length);
				fileStream.Flush(flushToDisk: true);
			}
			if (File.Exists(Path))
			{
				File.Replace(text2, Path, Path + ".bak");
			}
			else
			{
				File.Move(text2, Path);
			}
		}
	}
	public sealed class Ledger
	{
		private readonly Store store;

		public Registry Data { get; private set; }

		public Ledger(Store store, long world)
		{
			this.store = store;
			if (!File.Exists(store.Path))
			{
				Check.That(!File.Exists(store.Path + ".bak") && !File.Exists(store.Path + ".tmp"), "The main file is missing, but a backup or pending file exists: recovery required");
			}
			Data = (File.Exists(store.Path) ? store.Load<Registry>() : new Registry
			{
				World = world
			});
			Data.Validate(world);
		}

		private void Persist(Registry next)
		{
			next.Validate(Data.World);
			store.Save(next);
			Data = next;
		}

		public void Prepare(Transfer transfer)
		{
			Registry registry = Json.Copy(Data);
			Check.That(!registry.Pending.ContainsKey(transfer.Actor), "An operation is already in progress");
			registry.Pending.Add(transfer.Actor, transfer);
			Persist(registry);
		}

		public Transfer Commit(string actor, string id)
		{
			Check.That(Data.Pending.TryGetValue(actor, out var value) && value.Id == id, "Transaction not found");
			if (value.Phase == "committed")
			{
				return value;
			}
			Registry registry = Json.Copy(Data);
			Transfer transfer = registry.Pending[actor];
			transfer.Phase = "committed";
			registry.Traders[transfer.After.Id] = Json.Copy(transfer.After);
			Persist(registry);
			return Data.Pending[actor];
		}

		public void Applied(string actor, string id)
		{
			if (!Data.Pending.TryGetValue(actor, out var value))
			{
				Check.That(Data.Receipts.TryGetValue(actor, out var value2) && value2.Id == id, "Receipt not found");
				return;
			}
			Check.That(value.Id == id && value.Phase == "committed", "Transaction not confirmed");
			Registry registry = Json.Copy(Data);
			registry.Receipts[actor] = new Receipt
			{
				Id = id,
				Sequence = value.Sequence
			};
			registry.Pending.Remove(actor);
			Persist(registry);
		}

		public void Abort(string actor, string id)
		{
			Check.That(Data.Pending.TryGetValue(actor, out var value) && value.Id == id && value.Phase == "prepared", "A confirmed transaction cannot be cancelled");
			Registry registry = Json.Copy(Data);
			registry.Receipts[actor] = new Receipt
			{
				Id = id,
				Sequence = value.Sequence
			};
			registry.Pending.Remove(actor);
			Persist(registry);
		}

		public DropPlan Dismantle(string id, string actor, long revision, long character = 0L)
		{
			if (Data.Drops.TryGetValue(id, out var value))
			{
				Check.That(value.Owner == actor && value.OwnerCharacter == character, "Only the owner can do this");
				return value;
			}
			Check.That(Data.Traders.TryGetValue(id, out var value2), "Trader not found");
			Check.That(value2.IsOwner(actor, character), "Only the owner can do this");
			Check.That(value2.Place == PlaceState.Placed && value2.Revision == revision, "Data changed: open the trader again");
			Check.That(!Data.Pending.Values.Any((Transfer p) => p.After.Id == id), "The trader has an unfinished transaction");
			DropPlan dropPlan = DropPlan.From(value2);
			dropPlan.Validate();
			Registry registry = Json.Copy(Data);
			registry.Traders.Remove(id);
			registry.Drops.Add(id, dropPlan);
			Persist(registry);
			return Data.Drops[id];
		}

		public void CompleteDrops(IEnumerable<string> ids)
		{
			Registry registry = Json.Copy(Data);
			bool flag = false;
			foreach (string id in ids)
			{
				flag |= registry.Drops.Remove(id);
			}
			if (flag)
			{
				Persist(registry);
			}
		}
	}
	public sealed class TranslationCatalog
	{
		public sealed class Entry
		{
			public string Source;

			public string English;
		}

		private readonly Dictionary<string, Entry> entries;

		private readonly Dictionary<string, string> keys;

		private readonly string[] prefixes;

		private Dictionary<string, string> translated = new Dictionary<string, string>();

		public TranslationCatalog(string json)
		{
			entries = JsonConvert.DeserializeObject<Dictionary<string, Entry>>(json);
			if (entries == null || entries.Count == 0)
			{
				throw new InvalidDataException("Empty translation catalog");
			}
			keys = new Dictionary<string, string>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, Entry> entry in entries)
			{
				if (entry.Value?.Source == null || entry.Value.English == null)
				{
					throw new InvalidDataException(entry.Key);
				}
				keys[entry.Value.Source] = entry.Key;
			}
			prefixes = (from s in keys.Keys
				where s.EndsWith(": ", StringComparison.Ordinal)
				orderby s.Length descending
				select s).ToArray();
		}

		public string EnglishTemplate()
		{
			return JsonConvert.SerializeObject((object)entries.ToDictionary((KeyValuePair<string, Entry> e) => e.Key, (KeyValuePair<string, Entry> e) => e.Value.English), (Formatting)1);
		}

		private static string[] Arguments(string value)
		{
			return (from Match m in Regex.Matches(value, "(?<!\\{)\\{\\d+(?:[^{}]*)\\}(?!\\})")
				select m.Value into s
				orderby s
				select s).ToArray();
		}

		public void Load(string json, Action<string> warn)
		{
			translated = new Dictionary<string, string>();
			if (json == null)
			{
				return;
			}
			try
			{
				foreach (KeyValuePair<string, string> item in JsonConvert.DeserializeObject<Dictionary<string, string>>(json) ?? throw new InvalidDataException("Expected a JSON object"))
				{
					if (!entries.TryGetValue(item.Key, out var value))
					{
						continue;
					}
					if (string.IsNullOrWhiteSpace(item.Value) || !Arguments(value.English).SequenceEqual(Arguments(item.Value)))
					{
						warn?.Invoke("Invalid translation or placeholders: " + item.Key);
						continue;
					}
					int num = (from Match m in Regex.Matches(value.English, "\\{(\\d+)")
						select int.Parse(m.Groups[1].Value)).DefaultIfEmpty(-1).Max();
					try
					{
						string.Format(CultureInfo.InvariantCulture, item.Value, new object[num + 1]);
					}
					catch (FormatException)
					{
						warn?.Invoke("Invalid format: " + item.Key);
						continue;
					}
					translated[item.Key] = item.Value;
				}
			}
			catch (Exception ex2) when (ex2 is JsonException || ex2 is InvalidDataException)
			{
				translated.Clear();
				warn?.Invoke("Could not load translation; using English: " + ex2.Message);
			}
		}

		public string ByKey(string key)
		{
			if (!translated.TryGetValue(key, out var value))
			{
				if (!entries.TryGetValue(key, out var value2))
				{
					return key;
				}
				return value2.English;
			}
			return value;
		}

		public string Text(string source)
		{
			if (source == null || !keys.TryGetValue(source, out var value))
			{
				return source;
			}
			return ByKey(value);
		}

		public string Message(string source)
		{
			if (source == null)
			{
				return "";
			}
			if (keys.TryGetValue(source, out var value))
			{
				return ByKey(value);
			}
			string[] array = prefixes;
			foreach (string text in array)
			{
				if (source.StartsWith(text, StringComparison.Ordinal))
				{
					return Text(text) + Message(source.Substring(text.Length));
				}
			}
			return source;
		}

		public static void WriteTemplateIfMissing(string path, string text)
		{
			if (File.Exists(path))
			{
				return;
			}
			using FileStream stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.Read);
			using StreamWriter streamWriter = new StreamWriter(stream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
			streamWriter.Write(text);
		}
	}
	internal static class TranslationFiles
	{
		internal static string Read(string dllDirectory, string pluginDirectory, string language, Action<string> warn)
		{
			if (string.IsNullOrWhiteSpace(language) || language.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || language.Contains("/") || language.Contains("\\"))
			{
				return null;
			}
			string text = language.ToLowerInvariant() + "_PlayerTraders.json";
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			string path = Path.Combine(dllDirectory, text);
			if (File.Exists(path))
			{
				hashSet.Add(Path.GetFullPath(path));
			}
			Stack<string> stack = new Stack<string>();
			if (Directory.Exists(pluginDirectory))
			{
				stack.Push(Path.GetFullPath(pluginDirectory));
			}
			while (stack.Count > 0)
			{
				string text2 = stack.Pop();
				try
				{
					string text3 = Path.Combine(text2, text);
					if (File.Exists(text3))
					{
						hashSet.Add(text3);
					}
					string[] directories = Directory.GetDirectories(text2);
					foreach (string text4 in directories)
					{
						if ((File.GetAttributes(text4) & FileAttributes.ReparsePoint) == 0)
						{
							stack.Push(text4);
						}
					}
				}
				catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
				{
					warn?.Invoke("Could not inspect translation directory: " + text2 + ": " + ex.Message);
				}
			}
			string text5 = null;
			foreach (string item in hashSet)
			{
				try
				{
					if (new FileInfo(item).Length > 1048576)
					{
						warn?.Invoke("Translation exceeds 1 MiB; using English: " + item);
						return null;
					}
					string text6 = File.ReadAllText(item);
					if (text5 != null && text5 != text6)
					{
						warn?.Invoke("Conflicting " + text + " files found. Keep one translation installed; using English.");
						return null;
					}
					text5 = text6;
				}
				catch (Exception ex2) when (ex2 is IOException || ex2 is UnauthorizedAccessException)
				{
					warn?.Invoke("Could not read translation; using English: " + item + ": " + ex2.Message);
					return null;
				}
			}
			return text5;
		}
	}
}