using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;

[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("ItemDrawers.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+913107a17ca521c047e50107cd807fb5861366ab")]
[assembly: AssemblyProduct("ItemDrawers.Core")]
[assembly: AssemblyTitle("ItemDrawers.Core")]
[assembly: AssemblyVersion("1.0.0.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 ItemDrawers.Core
{
	public readonly struct IconSize
	{
		public readonly string Name;

		public readonly int Width;

		public readonly int Height;

		public IconSize(string name, int width, int height)
		{
			Name = name;
			Width = width;
			Height = height;
		}
	}
	public readonly struct AtlasRect
	{
		public readonly int X;

		public readonly int Y;

		public readonly int Width;

		public readonly int Height;

		public AtlasRect(int x, int y, int width, int height)
		{
			X = x;
			Y = y;
			Width = width;
			Height = height;
		}
	}
	public sealed class AtlasLayout
	{
		public int Width { get; }

		public int Height { get; }

		public IReadOnlyDictionary<string, AtlasRect> Rects { get; }

		public AtlasLayout(int width, int height, IReadOnlyDictionary<string, AtlasRect> rects)
		{
			Width = width;
			Height = height;
			Rects = rects;
		}

		public bool TryGetUv(string name, out float u0, out float v0, out float u1, out float v1)
		{
			u0 = (v0 = (u1 = (v1 = 0f)));
			if (name == null || !Rects.TryGetValue(name, out var value))
			{
				return false;
			}
			u0 = (float)value.X / (float)Width;
			v0 = (float)value.Y / (float)Height;
			u1 = (float)(value.X + value.Width) / (float)Width;
			v1 = (float)(value.Y + value.Height) / (float)Height;
			return true;
		}
	}
	public static class ChunkSplitter
	{
		public static IReadOnlyList<int> Chunks(int amount, int stackSize)
		{
			List<int> list = new List<int>();
			if (amount <= 0)
			{
				return list;
			}
			int num = ((stackSize < 1) ? 1 : stackSize);
			int num2 = amount;
			while (num2 > 0)
			{
				int num3 = ((num2 < num) ? num2 : num);
				list.Add(num3);
				num2 -= num3;
			}
			return list;
		}
	}
	public static class DrawerMeshBuilder
	{
		private const float UvScale = 1f;

		private static readonly int[] Signs = new int[2] { -1, 1 };

		public static MeshData Build(DrawerProportions p)
		{
			MeshData.Builder builder = new MeshData.Builder();
			float width = p.Width;
			float height = p.Height;
			float depth = p.Depth;
			float num = Math.Min(p.FrameThickness, Math.Min(width, height) / 2f - 0.02f);
			float num2 = Math.Min(p.RecessDepth, depth * 0.5f);
			float bevel = p.Bevel;
			AddChamferBox(builder, 0f, 0f, (0f - num2) / 2f, width, height, depth - num2, bevel);
			float cz = depth / 2f - num2 / 2f;
			AddChamferBox(builder, 0f, height / 2f - num / 2f, cz, width, num, num2, bevel);
			AddChamferBox(builder, 0f, (0f - height) / 2f + num / 2f, cz, width, num, num2, bevel);
			float num3 = height - 2f * num;
			if (num3 > 0.01f)
			{
				AddChamferBox(builder, (0f - width) / 2f + num / 2f, 0f, cz, num, num3, num2, bevel);
				AddChamferBox(builder, width / 2f - num / 2f, 0f, cz, num, num3, num2, bevel);
			}
			AddHandle(builder, p, num, num2);
			return builder.Build();
		}

		private static void AddHandle(MeshData.Builder gb, DrawerProportions p, float frame, float recess)
		{
			float num = p.Depth / 2f - recess;
			float num2 = p.Height - 2f * frame;
			switch (p.Handle)
			{
			case HandleStyle.Bar:
			{
				float w2 = Math.Min(p.HandleWidth, p.Width - 2f * frame - 0.02f);
				float cy = (0f - num2) / 2f + p.HandleSection * 1.4f;
				AddChamferBox(gb, 0f, cy, num + p.HandleProud / 2f, w2, p.HandleSection, p.HandleProud, Math.Min(p.Bevel, p.HandleSection / 2.5f));
				break;
			}
			case HandleStyle.Knobs:
			{
				float num3 = Math.Min(p.HandleWidth / 2f, p.Width / 2f - frame - p.HandleSection);
				for (int i = -1; i <= 1; i += 2)
				{
					AddChamferBox(gb, num3 * (float)i, 0f, num + p.HandleProud / 2f, p.HandleSection, p.HandleSection, p.HandleProud, p.HandleSection / 3f);
				}
				break;
			}
			case HandleStyle.Pull:
			{
				float w = Math.Min(p.HandleWidth, p.Width - 2f * frame);
				AddChamferBox(gb, 0f, (0f - p.Height) / 2f + frame + p.HandleSection / 2f, p.Depth / 2f - p.HandleProud / 2f, w, p.HandleSection, p.HandleProud, p.Bevel);
				break;
			}
			case HandleStyle.None:
				break;
			}
		}

		public static MeshData ChamferBox(float cx, float cy, float cz, float w, float h, float d, float chamfer)
		{
			MeshData.Builder builder = new MeshData.Builder();
			AddChamferBox(builder, cx, cy, cz, w, h, d, chamfer);
			return builder.Build();
		}

		private static void AddChamferBox(MeshData.Builder gb, float cx, float cy, float cz, float w, float h, float d, float chamfer)
		{
			float num = w / 2f;
			float num2 = h / 2f;
			float num3 = d / 2f;
			float num4 = Math.Max(0f, Math.Min(chamfer, Math.Min(num, Math.Min(num2, num3)) * 0.98f));
			float[] extent = new float[3] { num, num2, num3 };
			float[] inner = new float[3]
			{
				num - num4,
				num2 - num4,
				num3 - num4
			};
			float[] centre = new float[3] { cx, cy, cz };
			int[][] array = new int[4][]
			{
				new int[2] { -1, -1 },
				new int[2] { 1, -1 },
				new int[2] { 1, 1 },
				new int[2] { -1, 1 }
			};
			int[] signs;
			for (int i = 0; i < 3; i++)
			{
				signs = Signs;
				foreach (int num5 in signs)
				{
					int num6 = (i + 1) % 3;
					int num7 = (i + 2) % 3;
					float[][] array2 = new float[4][];
					for (int k = 0; k < 4; k++)
					{
						int[] array3 = new int[3];
						array3[i] = num5;
						array3[num6] = array[k][0];
						array3[num7] = array[k][1];
						array2[k] = Point(i, array3);
					}
					float[] array4 = new float[3];
					array4[i] = num5;
					gb.Quad(array2[0], array2[1], array2[2], array2[3], array4, 1f);
				}
			}
			for (int l = 0; l < 3; l++)
			{
				int num8 = (l + 1) % 3;
				int num9 = (l + 2) % 3;
				signs = Signs;
				foreach (int num10 in signs)
				{
					int[] signs2 = Signs;
					foreach (int num11 in signs2)
					{
						float[][] array5 = new float[2][];
						float[][] array6 = new float[2][];
						for (int n = 0; n < 2; n++)
						{
							int[] array7 = new int[3];
							array7[l] = Signs[n];
							array7[num8] = num10;
							array7[num9] = num11;
							array5[n] = Point(num8, array7);
							array6[n] = Point(num9, array7);
						}
						float[] array8 = new float[3];
						array8[num8] = num10;
						array8[num9] = num11;
						gb.Quad(array5[0], array5[1], array6[1], array6[0], array8, 1f);
					}
				}
			}
			signs = Signs;
			foreach (int num12 in signs)
			{
				int[] signs2 = Signs;
				foreach (int num13 in signs2)
				{
					int[] signs3 = Signs;
					foreach (int num15 in signs3)
					{
						int[] s = new int[3] { num12, num13, num15 };
						float[] hint = new float[3] { num12, num13, num15 };
						gb.TriangleHinted(Point(0, s), Point(1, s), Point(2, s), hint, 1f);
					}
				}
			}
			float[] Point(int axis, int[] array10)
			{
				float[] array9 = new float[3];
				for (int num16 = 0; num16 < 3; num16++)
				{
					array9[num16] = centre[num16] + (float)array10[num16] * ((num16 == axis) ? extent[num16] : inner[num16]);
				}
				return array9;
			}
		}
	}
	public readonly struct DrawerOutcome
	{
		public readonly bool Accepted;

		public readonly DrawerSnapshot Result;

		public readonly int MovedToDrawer;

		public readonly int MovedToPlayer;

		public readonly string Rejection;

		private DrawerOutcome(bool accepted, DrawerSnapshot result, int toDrawer, int toPlayer, string rejection)
		{
			Accepted = accepted;
			Result = result;
			MovedToDrawer = toDrawer;
			MovedToPlayer = toPlayer;
			Rejection = rejection;
		}

		public static DrawerOutcome Deposited(DrawerSnapshot result, int moved)
		{
			return new DrawerOutcome(accepted: true, result, moved, 0, null);
		}

		public static DrawerOutcome Withdrew(DrawerSnapshot result, int moved)
		{
			return new DrawerOutcome(accepted: true, result, 0, moved, null);
		}

		public static DrawerOutcome Changed(DrawerSnapshot result)
		{
			return new DrawerOutcome(accepted: true, result, 0, 0, null);
		}

		public static DrawerOutcome Refused(DrawerSnapshot unchanged, string why)
		{
			return new DrawerOutcome(accepted: false, unchanged, 0, 0, why);
		}
	}
	public enum HandleStyle
	{
		None,
		Bar,
		Knobs,
		Pull
	}
	public sealed class DrawerProportions
	{
		public float Width = 0.66f;

		public float Height = 0.66f;

		public float Depth = 0.66f;

		public float FrameThickness = 0.033f;

		public float RecessDepth = 0.0198f;

		public float Bevel = 0.00396f;

		public float HandleWidth = 0.264f;

		public float HandleSection = 0.0429f;

		public float HandleProud = 0.0231f;

		public HandleStyle Handle = HandleStyle.Bar;

		public float LabelScale = 0.98f;

		public float LabelSize
		{
			get
			{
				float num = Width - 2f * FrameThickness;
				float num2 = Height - 2f * FrameThickness;
				if (Handle == HandleStyle.Bar)
				{
					num2 -= HandleSection * 3f;
				}
				float num3 = ((num < num2) ? num : num2) * LabelScale;
				if (!(num3 < 0.05f))
				{
					return num3;
				}
				return 0.05f;
			}
		}
	}
	public readonly struct DrawerSnapshot : IEquatable<DrawerSnapshot>
	{
		public readonly string ItemName;

		public readonly int Amount;

		public bool IsAssigned => !string.IsNullOrEmpty(ItemName);

		public bool IsEmpty => Amount <= 0;

		public DrawerSnapshot(string itemName, int amount)
		{
			ItemName = itemName ?? "";
			Amount = ((amount >= 0) ? amount : 0);
		}

		public bool Equals(DrawerSnapshot other)
		{
			if (string.Equals(ItemName, other.ItemName, StringComparison.Ordinal))
			{
				return Amount == other.Amount;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is DrawerSnapshot other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((ItemName?.GetHashCode() ?? 0) * 397) ^ Amount;
		}

		public override string ToString()
		{
			if (!IsAssigned)
			{
				return "(empty drawer)";
			}
			return $"{ItemName} x{Amount}";
		}
	}
	public static class DrawerState
	{
		public const string WrongItem = "This drawer holds a different item";

		public const string DrawerFull = "This drawer is full";

		public const string DrawerEmpty = "This drawer has been drained";

		public const string NotAssigned = "This drawer has not been assigned";

		public const string BadCapacity = "This drawer has an invalid capacity";

		public const string NotEmptyYet = "Empty the drawer before clearing it";

		public const string NothingOffered = "Nothing to deposit";

		public static DrawerOutcome Deposit(DrawerSnapshot current, int capacity, string itemName, int offered)
		{
			if (offered <= 0)
			{
				return DrawerOutcome.Refused(current, "Nothing to deposit");
			}
			if (string.IsNullOrEmpty(itemName))
			{
				return DrawerOutcome.Refused(current, "Nothing to deposit");
			}
			if (capacity <= 0)
			{
				return DrawerOutcome.Refused(current, "This drawer has an invalid capacity");
			}
			if (current.IsAssigned && current.ItemName != itemName)
			{
				return DrawerOutcome.Refused(current, "This drawer holds a different item");
			}
			int num = capacity - current.Amount;
			if (num <= 0)
			{
				return DrawerOutcome.Refused(current, "This drawer is full");
			}
			int num2 = ((offered < num) ? offered : num);
			return DrawerOutcome.Deposited(new DrawerSnapshot(itemName, current.Amount + num2), num2);
		}

		public static DrawerOutcome WithdrawStack(DrawerSnapshot current, int maxStackSize)
		{
			if (!current.IsAssigned)
			{
				return DrawerOutcome.Refused(current, "This drawer has not been assigned");
			}
			if (current.IsEmpty)
			{
				return DrawerOutcome.Refused(current, "This drawer has been drained");
			}
			int num = ((maxStackSize < 1) ? 1 : maxStackSize);
			int num2 = ((current.Amount < num) ? current.Amount : num);
			return DrawerOutcome.Withdrew(new DrawerSnapshot(current.ItemName, current.Amount - num2), num2);
		}

		public static DrawerOutcome WithdrawOne(DrawerSnapshot current)
		{
			if (!current.IsAssigned)
			{
				return DrawerOutcome.Refused(current, "This drawer has not been assigned");
			}
			if (current.IsEmpty)
			{
				return DrawerOutcome.Refused(current, "This drawer has been drained");
			}
			return DrawerOutcome.Withdrew(new DrawerSnapshot(current.ItemName, current.Amount - 1), 1);
		}

		public static DrawerOutcome WithdrawExact(DrawerSnapshot current, int requested)
		{
			if (requested <= 0 || !current.IsAssigned || current.IsEmpty)
			{
				return DrawerOutcome.Withdrew(current, 0);
			}
			int num = ((requested < current.Amount) ? requested : current.Amount);
			return DrawerOutcome.Withdrew(new DrawerSnapshot(current.ItemName, current.Amount - num), num);
		}

		public static DrawerOutcome Clear(DrawerSnapshot current)
		{
			if (!current.IsEmpty)
			{
				return DrawerOutcome.Refused(current, "Empty the drawer before clearing it");
			}
			return DrawerOutcome.Changed(new DrawerSnapshot("", 0));
		}

		public static int RefundShortfall(int removed, int accepted)
		{
			int num = removed - accepted;
			if (num <= 0)
			{
				return 0;
			}
			return num;
		}
	}
	public static class DrawerTextureGenerator
	{
		private readonly struct Knot
		{
			public readonly float X;

			public readonly float Y;

			public readonly float Radius;

			public readonly float Strength;

			public Knot(float x, float y, float radius, float strength)
			{
				X = x;
				Y = y;
				Radius = radius;
				Strength = strength;
			}
		}

		public static TextureData Generate(TextureTier tier, int width, int height, int seed)
		{
			if (width < 2 || height < 2)
			{
				throw new ArgumentException($"Texture must be at least 2x2, got {width}x{height}.");
			}
			float[] heights = BuildHeightField(tier, width, height, seed);
			byte[] albedo = BuildAlbedo(tier, heights, width, height);
			byte[] normal = BuildNormal(heights, width, height, NormalStrength(tier));
			return new TextureData(width, height, albedo, normal);
		}

		private static float[] BuildHeightField(TextureTier tier, int width, int height, int seed)
		{
			return tier switch
			{
				TextureTier.Wood => BuildWoodHeight(width, height, seed), 
				TextureTier.Stone => BuildStoneHeight(width, height, seed), 
				TextureTier.BlackMarble => BuildMarbleHeight(width, height, seed), 
				_ => BuildWoodHeight(width, height, seed), 
			};
		}

		private static float[] BuildWoodHeight(int width, int height, int seed)
		{
			float[] array = new float[width * height];
			Knot[] knots = MakeKnots(seed, width, height, 3, 6f, 14f);
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					float num = PeriodicNoise.Fbm(j, i, width, height, seed + 11, 2, 7, 2f, 0.6f) * 1.3f;
					float num2 = (float)i * 7f / (float)height + num;
					float num3 = num2 - (float)Math.Floor(num2);
					float num4 = Math.Min(num3, 1f - num3);
					float num5 = 1f - Clamp01(num4 / 0.08f);
					float num6 = PeriodicNoise.Fbm(j, i, width, height, seed + 23, 4, 48, 2.1f, 0.55f);
					float num7 = PeriodicNoise.Fbm(j, i, width, height, seed + 37, 3, 5);
					float num8 = KnotContribution(knots, j, i, width, height);
					float v = 0.55f + num7 * 0.08f + num6 * 0.018f - num5 * 0.14f + num8;
					array[i * width + j] = Clamp01(v);
				}
			}
			return array;
		}

		private static float[] BuildStoneHeight(int width, int height, int seed)
		{
			float[] array = new float[width * height];
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					float num = PeriodicNoise.Fbm(j, i, width, height, seed + 5, 3, 6);
					float num2 = PeriodicNoise.Fbm(j, i, width, height, seed + 61, 3, 34);
					float v = 0.5f + num * 0.15f + num2 * 0.045f;
					array[i * width + j] = Clamp01(v);
				}
			}
			return array;
		}

		private static float[] BuildMarbleHeight(int width, int height, int seed)
		{
			float[] array = new float[width * height];
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					float value = PeriodicNoise.Fbm(j, i, width, height, seed + 7, 3, 5, 2.3f);
					float num = (float)Math.Pow(Clamp01((1f - Math.Abs(value) - 0.82f) / 0.18f), 2.0);
					float num2 = PeriodicNoise.Fbm(j, i, width, height, seed + 89, 2, 40);
					float v = 0.16f + num * 0.22f + num2 * 0.02f;
					array[i * width + j] = Clamp01(v);
				}
			}
			return array;
		}

		private static Knot[] MakeKnots(int seed, int width, int height, int count, float minRadius, float maxRadius)
		{
			Random random = new Random(seed + 999);
			Knot[] array = new Knot[count];
			float num = (float)width / 2f;
			float num2 = (float)height / 2f;
			float num3 = (float)width * 0.22f;
			float num4 = (float)height * 0.22f;
			for (int i = 0; i < count; i++)
			{
				float num5 = 0f;
				float num6 = 0f;
				for (int j = 0; j < 20; j++)
				{
					num5 = (float)(random.NextDouble() * (double)width);
					num6 = (float)(random.NextDouble() * (double)height);
					if (!(Math.Abs(num5 - num) < num3) || !(Math.Abs(num6 - num2) < num4))
					{
						break;
					}
				}
				float radius = minRadius + (float)random.NextDouble() * (maxRadius - minRadius);
				float strength = 0.03f + (float)random.NextDouble() * 0.03f;
				array[i] = new Knot(num5, num6, radius, strength);
			}
			return array;
		}

		private static float KnotContribution(Knot[] knots, int x, int y, int width, int height)
		{
			float num = 0f;
			for (int i = 0; i < knots.Length; i++)
			{
				Knot knot = knots[i];
				float num2 = PeriodicNoise.ToroidalDistance(x, y, knot.X, knot.Y, width, height);
				if (!(num2 >= knot.Radius))
				{
					float num3 = num2 / knot.Radius;
					float num4 = (float)Math.Pow(1f - num3, 2.0);
					num -= knot.Strength * num4;
				}
			}
			return num;
		}

		private static (float r, float g, float b) HueRatio(TextureTier tier)
		{
			return tier switch
			{
				TextureTier.Wood => (r: 1f, g: 0.84f, b: 0.66f), 
				TextureTier.Stone => (r: 0.97f, g: 0.98f, b: 1f), 
				TextureTier.BlackMarble => (r: 0.86f, g: 0.95f, b: 1f), 
				_ => (r: 1f, g: 0.8f, b: 0.56f), 
			};
		}

		public static float MidLightness(TextureTier tier)
		{
			var (num, num2) = LightnessRange(tier);
			return (num + num2) / 2f;
		}

		private static (float min, float max) LightnessRange(TextureTier tier)
		{
			return tier switch
			{
				TextureTier.Wood => (min: 0.24f, max: 0.6f), 
				TextureTier.Stone => (min: 0.34f, max: 0.64f), 
				TextureTier.BlackMarble => (min: 0.04f, max: 0.3f), 
				_ => (min: 0.28f, max: 0.66f), 
			};
		}

		private static byte[] BuildAlbedo(TextureTier tier, float[] heights, int width, int height)
		{
			(float r, float g, float b) tuple = HueRatio(tier);
			float item = tuple.r;
			float item2 = tuple.g;
			float item3 = tuple.b;
			(float min, float max) tuple2 = LightnessRange(tier);
			float item4 = tuple2.min;
			float item5 = tuple2.max;
			byte[] array = new byte[width * height * 4];
			for (int i = 0; i < heights.Length; i++)
			{
				float num = item4 + heights[i] * (item5 - item4);
				int num2 = i * 4;
				array[num2] = ToByte(num * item);
				array[num2 + 1] = ToByte(num * item2);
				array[num2 + 2] = ToByte(num * item3);
				array[num2 + 3] = byte.MaxValue;
			}
			return array;
		}

		private static float NormalStrength(TextureTier tier)
		{
			return tier switch
			{
				TextureTier.Wood => 3f, 
				TextureTier.Stone => 1.6f, 
				TextureTier.BlackMarble => 1.1f, 
				_ => 2f, 
			};
		}

		private static byte[] BuildNormal(float[] heights, int width, int height, float strength)
		{
			byte[] array = new byte[width * height * 4];
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					float num = At(heights, j - 1, i - 1, width, height);
					float num2 = At(heights, j, i - 1, width, height);
					float num3 = At(heights, j + 1, i - 1, width, height);
					float num4 = At(heights, j - 1, i, width, height);
					float num5 = At(heights, j + 1, i, width, height);
					float num6 = At(heights, j - 1, i + 1, width, height);
					float num7 = At(heights, j, i + 1, width, height);
					float num8 = At(heights, j + 1, i + 1, width, height);
					float num9 = num3 + 2f * num5 + num8 - (num + 2f * num4 + num6);
					float num10 = num6 + 2f * num7 + num8 - (num + 2f * num2 + num3);
					float num11 = (0f - num9) * strength;
					float num12 = (0f - num10) * strength;
					float num13 = 1f;
					float num14 = (float)Math.Sqrt(num11 * num11 + num12 * num12 + num13 * num13);
					num11 /= num14;
					num12 /= num14;
					num13 /= num14;
					int num15 = (i * width + j) * 4;
					array[num15] = ToByte(num11 * 0.5f + 0.5f);
					array[num15 + 1] = ToByte(num12 * 0.5f + 0.5f);
					array[num15 + 2] = ToByte(num13 * 0.5f + 0.5f);
					array[num15 + 3] = byte.MaxValue;
				}
			}
			return array;
		}

		private static float At(float[] field, int x, int y, int width, int height)
		{
			int num = (x % width + width) % width;
			int num2 = (y % height + height) % height;
			return field[num2 * width + num];
		}

		private static float Clamp01(float v)
		{
			if (!(v < 0f))
			{
				if (!(v > 1f))
				{
					return v;
				}
				return 1f;
			}
			return 0f;
		}

		private static byte ToByte(float v)
		{
			v = Clamp01(v);
			return (byte)Math.Round(v * 255f);
		}
	}
	public sealed class HandledRequestCache<T>
	{
		private readonly struct Entry
		{
			public readonly T Result;

			public readonly float RecordedAt;

			public Entry(T result, float recordedAt)
			{
				Result = result;
				RecordedAt = recordedAt;
			}
		}

		private readonly Dictionary<(long Sender, long Id), Entry> _entries = new Dictionary<(long, long), Entry>();

		private readonly float _lifetimeSeconds;

		public int Count => _entries.Count;

		public HandledRequestCache(float lifetimeSeconds)
		{
			_lifetimeSeconds = lifetimeSeconds;
		}

		public bool TryGet(long sender, long id, out T result)
		{
			if (_entries.TryGetValue((sender, id), out var value))
			{
				result = value.Result;
				return true;
			}
			result = default(T);
			return false;
		}

		public void Record(long sender, long id, T result, float now)
		{
			_entries[(sender, id)] = new Entry(result, now);
		}

		public void Prune(float now)
		{
			if (_entries.Count == 0)
			{
				return;
			}
			List<(long, long)> list = null;
			foreach (KeyValuePair<(long, long), Entry> entry in _entries)
			{
				if (now - entry.Value.RecordedAt > _lifetimeSeconds)
				{
					(list ?? (list = new List<(long, long)>())).Add(entry.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (var item in list)
			{
				_entries.Remove(item);
			}
		}
	}
	public static class IconAtlasPacker
	{
		private const int Padding = 2;

		public static AtlasLayout Pack(IReadOnlyList<IconSize> icons, int maxDimension = 4096)
		{
			if (icons == null)
			{
				throw new ArgumentNullException("icons");
			}
			if (icons.Count == 0)
			{
				return new AtlasLayout(1, 1, new Dictionary<string, AtlasRect>());
			}
			int num = maxDimension - 2;
			foreach (IconSize icon in icons)
			{
				if (icon.Width <= 0 || icon.Height <= 0)
				{
					throw new ArgumentException($"Icon '{icon.Name}' has invalid dimensions {icon.Width}×{icon.Height}. " + "Icon width and height must be positive.");
				}
				if (icon.Width > num || icon.Height > num)
				{
					throw new ArgumentException($"Icon '{icon.Name}' has dimensions {icon.Width}×{icon.Height}, " + $"but maximum icon size for maxDimension={maxDimension} is {num}×{num} " + $"(atlas dimension - {2} pixel padding).");
				}
			}
			List<IconSize> sorted = icons.OrderByDescending((IconSize i) => i.Height).ToList();
			for (int num2 = 64; num2 <= maxDimension; num2 *= 2)
			{
				if (TryPackInto(sorted, num2, out var rects))
				{
					return new AtlasLayout(num2, num2, rects);
				}
			}
			throw new InvalidOperationException($"Cannot fit {icons.Count} icons into a {maxDimension}×{maxDimension} atlas.");
		}

		private static bool TryPackInto(List<IconSize> sorted, int size, out Dictionary<string, AtlasRect> rects)
		{
			rects = new Dictionary<string, AtlasRect>(sorted.Count);
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (IconSize item in sorted)
			{
				int num4 = item.Width + 2;
				int num5 = item.Height + 2;
				if (num4 > size || num5 > size)
				{
					return false;
				}
				if (num3 + num4 > size)
				{
					num += num2;
					num2 = 0;
					num3 = 0;
				}
				if (num + num5 > size)
				{
					return false;
				}
				rects[item.Name] = new AtlasRect(num3, num, item.Width, item.Height);
				num3 += num4;
				if (num5 > num2)
				{
					num2 = num5;
				}
			}
			return true;
		}
	}
	public sealed class MeshData
	{
		internal sealed class Builder
		{
			private readonly List<float> _pos = new List<float>(4096);

			private readonly List<float> _nor = new List<float>(4096);

			private readonly List<float> _uv = new List<float>(2731);

			public void Triangle(float[] a, float[] b, float[] c, float uvScale)
			{
				float num = b[0] - a[0];
				float num2 = b[1] - a[1];
				float num3 = b[2] - a[2];
				float num4 = c[0] - a[0];
				float num5 = c[1] - a[1];
				float num6 = c[2] - a[2];
				float num7 = num2 * num6 - num3 * num5;
				float num8 = num3 * num4 - num * num6;
				float num9 = num * num5 - num2 * num4;
				float num10 = (float)Math.Sqrt(num7 * num7 + num8 * num8 + num9 * num9);
				if (!(num10 < 1E-09f))
				{
					num7 /= num10;
					num8 /= num10;
					num9 /= num10;
					float num11 = Math.Abs(num7);
					float num12 = Math.Abs(num8);
					float num13 = Math.Abs(num9);
					int num14;
					int num15;
					if (num11 >= num12 && num11 >= num13)
					{
						num14 = 2;
						num15 = 1;
					}
					else if (num12 >= num13)
					{
						num14 = 0;
						num15 = 2;
					}
					else
					{
						num14 = 0;
						num15 = 1;
					}
					float[][] array = new float[3][] { a, b, c };
					foreach (float[] array2 in array)
					{
						_pos.Add(array2[0]);
						_pos.Add(array2[1]);
						_pos.Add(array2[2]);
						_nor.Add(num7);
						_nor.Add(num8);
						_nor.Add(num9);
						_uv.Add(array2[num14] * uvScale);
						_uv.Add(array2[num15] * uvScale);
					}
				}
			}

			public void Quad(float[] a, float[] b, float[] c, float[] d, float[] hint, float uvScale)
			{
				float num = b[0] - a[0];
				float num2 = b[1] - a[1];
				float num3 = b[2] - a[2];
				float num4 = c[0] - a[0];
				float num5 = c[1] - a[1];
				float num6 = c[2] - a[2];
				float num7 = num2 * num6 - num3 * num5;
				float num8 = num3 * num4 - num * num6;
				float num9 = num * num5 - num2 * num4;
				if (num7 * hint[0] + num8 * hint[1] + num9 * hint[2] < 0f)
				{
					float[] array = b;
					b = d;
					d = array;
				}
				Triangle(a, b, c, uvScale);
				Triangle(a, c, d, uvScale);
			}

			public void TriangleHinted(float[] a, float[] b, float[] c, float[] hint, float uvScale)
			{
				float num = b[0] - a[0];
				float num2 = b[1] - a[1];
				float num3 = b[2] - a[2];
				float num4 = c[0] - a[0];
				float num5 = c[1] - a[1];
				float num6 = c[2] - a[2];
				float num7 = num2 * num6 - num3 * num5;
				float num8 = num3 * num4 - num * num6;
				float num9 = num * num5 - num2 * num4;
				if (num7 * hint[0] + num8 * hint[1] + num9 * hint[2] < 0f)
				{
					float[] array = b;
					b = c;
					c = array;
				}
				Triangle(a, b, c, uvScale);
			}

			public MeshData Build()
			{
				return new MeshData(_pos.ToArray(), _nor.ToArray(), _uv.ToArray());
			}
		}

		public float[] Vertices { get; }

		public float[] Normals { get; }

		public float[] Uvs { get; }

		public int VertexCount => Vertices.Length / 3;

		public int TriangleCount => VertexCount / 3;

		public MeshData(float[] vertices, float[] normals, float[] uvs)
		{
			Vertices = vertices;
			Normals = normals;
			Uvs = uvs;
		}
	}
	public readonly struct MirrorDelta : IEquatable<MirrorDelta>
	{
		public readonly int Withdraw;

		public static readonly MirrorDelta None = new MirrorDelta(0);

		private MirrorDelta(int withdraw)
		{
			Withdraw = withdraw;
		}

		public static MirrorDelta WithdrawOf(int amount)
		{
			return new MirrorDelta(amount);
		}

		public bool Equals(MirrorDelta other)
		{
			return Withdraw == other.Withdraw;
		}

		public override bool Equals(object obj)
		{
			if (obj is MirrorDelta other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Withdraw;
		}

		public override string ToString()
		{
			if (Withdraw <= 0)
			{
				return "None";
			}
			return $"Withdraw({Withdraw})";
		}
	}
	public static class MirrorReconciliation
	{
		public static MirrorDelta Compute(string mirrorItemName, int mirrorTotal, string mirroredBaselineItemName, int mirroredBaselineAmount, string zdoItemName, int zdoAmount)
		{
			if (mirrorItemName != mirroredBaselineItemName)
			{
				return MirrorDelta.None;
			}
			if (mirroredBaselineItemName != zdoItemName)
			{
				return MirrorDelta.None;
			}
			int num = mirrorTotal - mirroredBaselineAmount;
			if (num >= 0)
			{
				return MirrorDelta.None;
			}
			int num2 = -num;
			int num3 = ((num2 < zdoAmount) ? num2 : zdoAmount);
			if (num3 > 0)
			{
				return MirrorDelta.WithdrawOf(num3);
			}
			return MirrorDelta.None;
		}
	}
	public sealed class PendingRequest<T>
	{
		public readonly long Id;

		public readonly T Payload;

		public int Attempts;

		public float Deadline;

		public PendingRequest(long id, T payload, int attempts, float deadline)
		{
			Id = id;
			Payload = payload;
			Attempts = attempts;
			Deadline = deadline;
		}
	}
	public sealed class PendingRequestLedger<T>
	{
		private readonly Dictionary<long, PendingRequest<T>> _pending = new Dictionary<long, PendingRequest<T>>();

		private readonly float _timeoutSeconds;

		private readonly int _maxAttempts;

		public int Count => _pending.Count;

		public PendingRequestLedger(float timeoutSeconds, int maxAttempts)
		{
			_timeoutSeconds = timeoutSeconds;
			_maxAttempts = maxAttempts;
		}

		public void Add(long id, T payload, float now)
		{
			_pending[id] = new PendingRequest<T>(id, payload, 1, now + _timeoutSeconds);
		}

		public bool TryComplete(long id, out T payload)
		{
			if (_pending.TryGetValue(id, out var value))
			{
				payload = value.Payload;
				_pending.Remove(id);
				return true;
			}
			payload = default(T);
			return false;
		}

		public bool Remove(long id, out T payload)
		{
			if (_pending.TryGetValue(id, out var value))
			{
				payload = value.Payload;
				_pending.Remove(id);
				return true;
			}
			payload = default(T);
			return false;
		}

		public IEnumerable<KeyValuePair<long, T>> All()
		{
			foreach (KeyValuePair<long, PendingRequest<T>> item in _pending)
			{
				yield return new KeyValuePair<long, T>(item.Key, item.Value.Payload);
			}
		}

		public void Tick(float now, Action<long, T> retry, Action<long, T> giveUp)
		{
			List<long> list = null;
			foreach (KeyValuePair<long, PendingRequest<T>> item in _pending)
			{
				if (!(now < item.Value.Deadline))
				{
					(list ?? (list = new List<long>())).Add(item.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (long item2 in list)
			{
				PendingRequest<T> pendingRequest = _pending[item2];
				if (pendingRequest.Attempts >= _maxAttempts)
				{
					_pending.Remove(item2);
					giveUp(item2, pendingRequest.Payload);
				}
				else
				{
					pendingRequest.Attempts++;
					pendingRequest.Deadline = now + _timeoutSeconds;
					retry(item2, pendingRequest.Payload);
				}
			}
		}
	}
	public static class PeriodicNoise
	{
		public static float Sample(float x, float y, int cells, int seed)
		{
			if (cells < 1)
			{
				cells = 1;
			}
			float num = (float)Math.Floor(x);
			float num2 = (float)Math.Floor(y);
			int num3 = Mod((int)num, cells);
			int num4 = Mod((int)num2, cells);
			int x2 = Mod(num3 + 1, cells);
			int y2 = Mod(num4 + 1, cells);
			float t = x - num;
			float t2 = y - num2;
			float t3 = Fade(t);
			float t4 = Fade(t2);
			float a = HashValue(num3, num4, seed);
			float b = HashValue(x2, num4, seed);
			float a2 = HashValue(num3, y2, seed);
			float b2 = HashValue(x2, y2, seed);
			float a3 = Lerp(a, b, t3);
			float b3 = Lerp(a2, b2, t3);
			return Lerp(a3, b3, t4);
		}

		public static float Fbm(float px, float py, int width, int height, int seed, int octaves, int baseCells, float lacunarity = 2f, float gain = 0.5f)
		{
			float num = 0f;
			float num2 = 1f;
			float num3 = 0f;
			int num4 = Math.Max(1, baseCells);
			for (int i = 0; i < octaves; i++)
			{
				float x = px * (float)num4 / (float)width;
				float y = py * (float)num4 / (float)height;
				num += Sample(x, y, num4, seed + i * 101) * num2;
				num3 += num2;
				num2 *= gain;
				num4 = Math.Max(1, (int)Math.Round((float)num4 * lacunarity));
			}
			if (!(num3 > 0f))
			{
				return 0f;
			}
			return num / num3;
		}

		public static float ToroidalDistance(float ax, float ay, float bx, float by, int width, int height)
		{
			float num = WrapDelta(ax - bx, width);
			float num2 = WrapDelta(ay - by, height);
			return (float)Math.Sqrt(num * num + num2 * num2);
		}

		private static float WrapDelta(float d, int period)
		{
			d %= (float)period;
			if (d > (float)period / 2f)
			{
				d -= (float)period;
			}
			if (d < (float)(-period) / 2f)
			{
				d += (float)period;
			}
			return d;
		}

		private static int Mod(int a, int m)
		{
			int num = a % m;
			if (num >= 0)
			{
				return num;
			}
			return num + m;
		}

		private static float Fade(float t)
		{
			return t * t * t * (t * (t * 6f - 15f) + 10f);
		}

		private static float Lerp(float a, float b, float t)
		{
			return a + t * (b - a);
		}

		private static float HashValue(int x, int y, int seed)
		{
			int num = x * 374761393 + y * 668265263 + seed * 1274126177;
			int num2 = (num ^ (num >>> 13)) * 1274126177;
			return (float)(uint)(num2 ^ (num2 >>> 16)) / 4.2949673E+09f * 2f - 1f;
		}
	}
	public sealed class RequestIdGenerator
	{
		private long _next;

		public RequestIdGenerator(long seed)
		{
			_next = seed;
		}

		public long Next()
		{
			return ++_next;
		}
	}
	public sealed class SpatialGrid<T>
	{
		private readonly struct Cell : IEquatable<Cell>
		{
			public readonly int X;

			public readonly int Y;

			public readonly int Z;

			public Cell(int x, int y, int z)
			{
				X = x;
				Y = y;
				Z = z;
			}

			public bool Equals(Cell o)
			{
				if (X == o.X && Y == o.Y)
				{
					return Z == o.Z;
				}
				return false;
			}

			public override bool Equals(object o)
			{
				if (o is Cell o2)
				{
					return Equals(o2);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (X * 73856093) ^ (Y * 19349663) ^ (Z * 83492791);
			}
		}

		private readonly float _cellSize;

		private readonly Dictionary<Cell, List<T>> _cells = new Dictionary<Cell, List<T>>();

		private readonly Dictionary<T, (Cell cell, float x, float y, float z)> _index = new Dictionary<T, (Cell, float, float, float)>();

		public int Count => _index.Count;

		public SpatialGrid(float cellSize)
		{
			if (cellSize <= 0f)
			{
				throw new ArgumentOutOfRangeException("cellSize");
			}
			_cellSize = cellSize;
		}

		private Cell CellOf(float x, float y, float z)
		{
			return new Cell((int)Math.Floor(x / _cellSize), (int)Math.Floor(y / _cellSize), (int)Math.Floor(z / _cellSize));
		}

		public void Insert(T item, float x, float y, float z)
		{
			if (_index.ContainsKey(item))
			{
				Move(item, x, y, z);
				return;
			}
			Cell cell = CellOf(x, y, z);
			if (!_cells.TryGetValue(cell, out var value))
			{
				value = new List<T>(4);
				_cells[cell] = value;
			}
			value.Add(item);
			_index[item] = (cell, x, y, z);
		}

		public bool Remove(T item)
		{
			if (!_index.TryGetValue(item, out (Cell, float, float, float) value))
			{
				return false;
			}
			if (_cells.TryGetValue(value.Item1, out var value2))
			{
				value2.Remove(item);
				if (value2.Count == 0)
				{
					_cells.Remove(value.Item1);
				}
			}
			_index.Remove(item);
			return true;
		}

		public void Move(T item, float x, float y, float z)
		{
			Remove(item);
			Insert(item, x, y, z);
		}

		public void Query(float x, float y, float z, float radius, List<T> results)
		{
			if (results == null)
			{
				throw new ArgumentNullException("results");
			}
			if (radius <= 0f)
			{
				return;
			}
			int num = (int)Math.Ceiling(radius / _cellSize);
			Cell cell = CellOf(x, y, z);
			float num2 = radius * radius;
			for (int i = -num; i <= num; i++)
			{
				for (int j = -num; j <= num; j++)
				{
					for (int k = -num; k <= num; k++)
					{
						Cell key = new Cell(cell.X + i, cell.Y + j, cell.Z + k);
						if (!_cells.TryGetValue(key, out var value))
						{
							continue;
						}
						for (int l = 0; l < value.Count; l++)
						{
							T val = value[l];
							(Cell cell, float x, float y, float z) tuple = _index[val];
							float num3 = tuple.x - x;
							float num4 = tuple.y - y;
							float num5 = tuple.z - z;
							if (num3 * num3 + num4 * num4 + num5 * num5 <= num2)
							{
								results.Add(val);
							}
						}
					}
				}
			}
		}
	}
	public sealed class TextureData
	{
		public int Width { get; }

		public int Height { get; }

		public byte[] Albedo { get; }

		public byte[] Normal { get; }

		public TextureData(int width, int height, byte[] albedo, byte[] normal)
		{
			Width = width;
			Height = height;
			Albedo = albedo;
			Normal = normal;
		}
	}
	public enum TextureTier
	{
		Wood,
		Stone,
		BlackMarble
	}
}