using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using ExtraPotions.Magpie.Config;
using ExtraPotions.Magpie.Items;
using ExtraPotions.Magpie.Loot;
using ExtraPotions.Magpie.StepAside;
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("ExtraPotions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2026 expDARE (ExtraPotions Meadworks)")]
[assembly: AssemblyFileVersion("0.1.13.0")]
[assembly: AssemblyInformationalVersion("0.1.13+254080b9351ec46e3f31fa4a55580d9d8cf592f1")]
[assembly: AssemblyProduct("Magpie.Core")]
[assembly: AssemblyTitle("Magpie.Core")]
[assembly: AssemblyVersion("0.1.13.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 ExtraPotions.Magpie
{
	public static class MagpieCore
	{
		public const string ProductId = "com.meadworks.magpie";

		public const string LootMarkKey = "magpie.loot";

		public const string CheatedMarkKey = "magpie.cheated";

		public const string InstanceTokenKey = "magpie.id";

		public const string MergeInKey = "magpie.merge_in";

		public const string MergeOutKey = "magpie.merge_out";
	}
}
namespace ExtraPotions.Magpie.Text
{
	public static class MagpieTextKeys
	{
		public const string Namespace = "magpie";

		public const string LootMultiplier = "loot_multiplier";

		public const string ModulePickup = "module_pickup";

		public const string ModuleMerge = "module_merge";

		public const string ModuleFloat = "module_float";

		public const string ModuleLoot = "module_loot";

		public const string StepAsidePickup = "step_aside_pickup";

		public const string StepAsideMerge = "step_aside_merge";

		public const string StepAsideFloat = "step_aside_float";

		public const string StepAsideLoot = "step_aside_loot";

		public const string ImportDone = "import_done";

		public const string ImportSyncIncomplete = "import_sync_incomplete";

		public static IReadOnlyList<string> All { get; } = new string[11]
		{
			"loot_multiplier", "module_pickup", "module_merge", "module_float", "module_loot", "step_aside_pickup", "step_aside_merge", "step_aside_float", "step_aside_loot", "import_done",
			"import_sync_incomplete"
		};

		public static string Token(string key)
		{
			return "$meadworks_magpie_" + key;
		}
	}
}
namespace ExtraPotions.Magpie.StepAside
{
	[Flags]
	public enum MagpieModule
	{
		None = 0,
		Pickup = 1,
		Merge = 2,
		Float = 4,
		Loot = 8,
		All = 0xF
	}
	public readonly struct ModuleSource
	{
		public string Guid { get; }

		public string Name { get; }

		public ModuleSource(string guid, string name)
		{
			Guid = guid;
			Name = name;
		}
	}
	public static class ModuleStepAside
	{
		public const string SwiftPickupGuid = "user.swiftpickup";

		public const string FloatingItemsGuid = "com.ab5olutezer0.valheim.floatingitems";

		public const string LegacyFloatingItemsGuid = "com.michal.valheim.floatingitems";

		public const string SwiftPickupConfigFile = "user.swiftpickup.cfg";

		private static readonly ModuleSource Swift = new ModuleSource("user.swiftpickup", "SwiftPickup");

		private static readonly ModuleSource Floating = new ModuleSource("com.ab5olutezer0.valheim.floatingitems", "FloatingItems");

		private static readonly ModuleSource FloatingLegacy = new ModuleSource("com.michal.valheim.floatingitems", "FloatingItems");

		public static readonly MagpieModule[] Modules = new MagpieModule[4]
		{
			MagpieModule.Pickup,
			MagpieModule.Merge,
			MagpieModule.Float,
			MagpieModule.Loot
		};

		public static string ModuleId(MagpieModule module)
		{
			return module switch
			{
				MagpieModule.Pickup => "pickup", 
				MagpieModule.Merge => "merge", 
				MagpieModule.Float => "float", 
				MagpieModule.Loot => "loot", 
				_ => throw new ArgumentException("Expected exactly one Magpie module.", "module"), 
			};
		}

		public static string TextKey(MagpieModule module)
		{
			return module switch
			{
				MagpieModule.Pickup => "step_aside_pickup", 
				MagpieModule.Merge => "step_aside_merge", 
				MagpieModule.Float => "step_aside_float", 
				MagpieModule.Loot => "step_aside_loot", 
				_ => throw new ArgumentException("Expected exactly one Magpie module.", "module"), 
			};
		}

		public static ModuleSource? InstalledSource(MagpieModule module, IEnumerable<string> installed, bool? mergeNearbyDrops)
		{
			HashSet<string> hashSet = new HashSet<string>(installed ?? Enumerable.Empty<string>(), StringComparer.Ordinal);
			foreach (ModuleSource item in Sources(module, mergeNearbyDrops))
			{
				if (hashSet.Contains(item.Guid))
				{
					return item;
				}
			}
			return null;
		}

		public static IReadOnlyList<ModuleSource> Sources(MagpieModule module, bool? mergeNearbyDrops)
		{
			switch (module)
			{
			case MagpieModule.Pickup:
			case MagpieModule.Loot:
				return new ModuleSource[1] { Swift };
			case MagpieModule.Merge:
				if (mergeNearbyDrops == false)
				{
					return Array.Empty<ModuleSource>();
				}
				return new ModuleSource[1] { Swift };
			case MagpieModule.Float:
				return new ModuleSource[2] { Floating, FloatingLegacy };
			default:
				return Array.Empty<ModuleSource>();
			}
		}

		public static MagpieModule Yielding(IEnumerable<string> installed, bool? mergeNearbyDrops)
		{
			HashSet<string> set = new HashSet<string>(installed ?? Enumerable.Empty<string>(), StringComparer.Ordinal);
			MagpieModule magpieModule = MagpieModule.None;
			MagpieModule[] modules = Modules;
			foreach (MagpieModule magpieModule2 in modules)
			{
				if (Sources(magpieModule2, mergeNearbyDrops).Any((ModuleSource s) => set.Contains(s.Guid)))
				{
					magpieModule |= magpieModule2;
				}
			}
			return magpieModule;
		}

		public static bool? ReadMergeNearbyDrops(string? configText)
		{
			if (configText == null)
			{
				return null;
			}
			string a = "";
			string[] array = configText.Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0 || text[0] == '#')
				{
					continue;
				}
				if (text[0] == '[' && text[text.Length - 1] == ']')
				{
					a = text.Substring(1, text.Length - 2).Trim();
					continue;
				}
				int num = text.IndexOf('=');
				if (num > 0 && string.Equals(a, "Merge", StringComparison.OrdinalIgnoreCase) && string.Equals(text.Substring(0, num).Trim(), "MergeNearbyDrops", StringComparison.OrdinalIgnoreCase))
				{
					if (!bool.TryParse(text.Substring(num + 1).Trim(), out var result))
					{
						return null;
					}
					return result;
				}
			}
			return null;
		}
	}
}
namespace ExtraPotions.Magpie.Pickup
{
	public enum MagnetAction
	{
		Outside,
		Pull,
		Take
	}
	public readonly struct MagnetStep
	{
		public MagnetAction Action { get; }

		public float Move { get; }

		public MagnetStep(MagnetAction action, float move)
		{
			Action = action;
			Move = move;
		}
	}
	public static class Magnet
	{
		public const float TakeDistance = 0.3f;

		public static MagnetStep Step(float distance, float radius, float speed, float deltaTime)
		{
			if (float.IsNaN(distance) || float.IsInfinity(distance) || distance > radius)
			{
				return new MagnetStep(MagnetAction.Outside, 0f);
			}
			if (distance < 0.3f)
			{
				return new MagnetStep(MagnetAction.Take, 0f);
			}
			float val = Math.Max(0f, speed) * Math.Max(0f, deltaTime);
			return new MagnetStep(MagnetAction.Pull, Math.Min(val, distance));
		}
	}
	public sealed class PickupLine<T>
	{
		public string Key { get; }

		public int Amount { get; internal set; }

		public T Payload { get; }

		public double Opened { get; }

		public PickupLine(string key, int amount, T payload, double opened)
		{
			Key = key;
			Amount = amount;
			Payload = payload;
			Opened = opened;
		}
	}
	public sealed class PickupMessageGroup<T>
	{
		public const double Window = 1.0;

		private readonly List<PickupLine<T>> open = new List<PickupLine<T>>();

		private readonly List<bool> immediate = new List<bool>();

		public int Pending => open.Count;

		public void Add(string key, int amount, double now, T payload, bool grouping)
		{
			if (amount <= 0)
			{
				return;
			}
			if (grouping)
			{
				for (int i = 0; i < open.Count; i++)
				{
					if (!immediate[i] && open[i].Key == key)
					{
						open[i].Amount += amount;
						return;
					}
				}
			}
			open.Add(new PickupLine<T>(key, amount, payload, now));
			immediate.Add(!grouping);
		}

		public IReadOnlyList<PickupLine<T>> Flush(double now)
		{
			List<PickupLine<T>> list = new List<PickupLine<T>>();
			int num = 0;
			while (num < open.Count)
			{
				if (immediate[num] || now - open[num].Opened >= 1.0)
				{
					list.Add(open[num]);
					open.RemoveAt(num);
					immediate.RemoveAt(num);
				}
				else
				{
					num++;
				}
			}
			return list;
		}

		public void Clear()
		{
			open.Clear();
			immediate.Clear();
		}
	}
	public readonly struct PickupFacts
	{
		public bool AutoPickup { get; }

		public bool IsPiece { get; }

		public bool Valid { get; }

		public bool HaveUnique { get; }

		public bool Ignored { get; }

		public bool Owned { get; }

		public bool InTar { get; }

		public bool Fits { get; }

		public PickupFacts(bool autoPickup, bool isPiece, bool valid, bool haveUnique, bool ignored, bool owned, bool inTar, bool fits)
		{
			AutoPickup = autoPickup;
			IsPiece = isPiece;
			Valid = valid;
			HaveUnique = haveUnique;
			Ignored = ignored;
			Owned = owned;
			InTar = inTar;
			Fits = fits;
		}
	}
	public enum PickupAction
	{
		Skip,
		RequestOwnership,
		Hold,
		Pull
	}
	public static class PickupRules
	{
		public static PickupAction Decide(PickupFacts item)
		{
			if (!item.AutoPickup || item.IsPiece || !item.Valid || item.HaveUnique || item.Ignored)
			{
				return PickupAction.Skip;
			}
			if (!item.Owned)
			{
				return PickupAction.RequestOwnership;
			}
			if (item.InTar || !item.Fits)
			{
				return PickupAction.Hold;
			}
			return PickupAction.Pull;
		}

		public static bool CanTakeNow(bool valid, bool owned)
		{
			return valid && owned;
		}
	}
	public sealed class PickupScheduler
	{
		private double nextScan = double.NegativeInfinity;

		private int remaining;

		private bool unlimited;

		private int lastTakeFrame = int.MinValue;

		public bool ScanDue(double now, float interval)
		{
			if (now + 1E-06 < nextScan)
			{
				return false;
			}
			nextScan = now + Math.Max(0.0, interval);
			return true;
		}

		public void BeginScan(int budget)
		{
			unlimited = budget <= 0;
			remaining = Math.Max(0, budget);
		}

		public bool TryTake(int frame)
		{
			if (frame == lastTakeFrame || (!unlimited && remaining <= 0))
			{
				return false;
			}
			lastTakeFrame = frame;
			if (!unlimited)
			{
				remaining--;
			}
			return true;
		}

		public void Reset()
		{
			nextScan = double.NegativeInfinity;
			remaining = 0;
			unlimited = false;
			lastTakeFrame = int.MinValue;
		}
	}
}
namespace ExtraPotions.Magpie.Merging
{
	public readonly struct Point3
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public Point3(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public float DistanceSquared(Point3 other)
		{
			float num = X - other.X;
			float num2 = Y - other.Y;
			float num3 = Z - other.Z;
			return num * num + num2 * num2 + num3 * num3;
		}
	}
	public sealed class GroundItem
	{
		public long Id { get; }

		public ItemIdentity Identity { get; }

		public int Stack { get; }

		public int MaxStack { get; }

		public Point3 Position { get; }

		public long Created { get; }

		public double SpawnTime { get; }

		public bool OwnedLocally { get; }

		public bool Valid { get; }

		public bool Moving { get; }

		public double AgeSeconds { get; }

		public bool Pulled { get; }

		public bool PendingIntent { get; }

		public string? Token { get; }

		public GroundItem(long id, ItemIdentity identity, int stack, int maxStack, Point3 position, long created, double spawnTime, bool ownedLocally, bool valid, bool moving, double ageSeconds, bool pulled, bool pendingIntent, string? token)
		{
			Id = id;
			Identity = identity;
			Stack = stack;
			MaxStack = maxStack;
			Position = position;
			Created = created;
			SpawnTime = spawnTime;
			OwnedLocally = ownedLocally;
			Valid = valid;
			Moving = moving;
			AgeSeconds = ageSeconds;
			Pulled = pulled;
			PendingIntent = pendingIntent;
			Token = token;
		}
	}
	public enum BarrierState
	{
		Pass,
		Unavailable
	}
	public enum MergeRole
	{
		None,
		SinglePlayer,
		Server,
		RemoteClient
	}
	public static class MergeBarrier
	{
		public static BarrierState Decide(MergeRole role)
		{
			if (role != MergeRole.SinglePlayer && role != MergeRole.Server)
			{
				return BarrierState.Unavailable;
			}
			return BarrierState.Pass;
		}

		public static bool MayMerge(MergeRole role)
		{
			return Decide(role) == BarrierState.Pass;
		}
	}
	public sealed class MergeIntent
	{
		public const string Version = "v1";

		public const string VersionWithFlag = "v2";

		public const int MaxSourceNonces = 8;

		public string Nonce { get; }

		public string SourceToken { get; }

		public int Moved { get; }

		public double WorldTime { get; }

		public bool TracksPhase2 { get; }

		public bool Phase2Saved { get; }

		public int? PreMergeStack { get; }

		public bool? DestroysSource { get; }

		public MergeIntent(string nonce, string sourceToken, int moved, double worldTime)
			: this(nonce, sourceToken, moved, worldTime, tracksPhase2: true, phase2Saved: false)
		{
		}

		private MergeIntent(string nonce, string sourceToken, int moved, double worldTime, bool tracksPhase2, bool phase2Saved, int? preMergeStack = null, bool? destroysSource = null)
		{
			if (!ValidField(nonce))
			{
				throw new ArgumentException("Nonce must be non-empty and contain no ';'.", "nonce");
			}
			if (!ValidField(sourceToken))
			{
				throw new ArgumentException("Source token must be non-empty and contain no ';'.", "sourceToken");
			}
			if (moved <= 0)
			{
				throw new ArgumentException("Moved amount must be above zero.", "moved");
			}
			if (double.IsNaN(worldTime) || double.IsInfinity(worldTime))
			{
				throw new ArgumentException("World time must be finite.", "worldTime");
			}
			if (preMergeStack.HasValue && preMergeStack.Value < 1)
			{
				throw new ArgumentException("Pre-merge stack must be at least 1.", "preMergeStack");
			}
			if (!preMergeStack.HasValue && destroysSource.HasValue)
			{
				throw new ArgumentException("A removal bit requires a pre-merge stack.", "destroysSource");
			}
			Nonce = nonce;
			SourceToken = sourceToken;
			Moved = moved;
			WorldTime = worldTime;
			TracksPhase2 = tracksPhase2;
			Phase2Saved = phase2Saved;
			PreMergeStack = preMergeStack;
			DestroysSource = destroysSource;
		}

		public MergeIntent WithPhase2Saved()
		{
			return new MergeIntent(Nonce, SourceToken, Moved, WorldTime, tracksPhase2: true, phase2Saved: true, PreMergeStack, DestroysSource);
		}

		public MergeIntent WithBaseline(int preMergeStack, bool destroysSource)
		{
			return new MergeIntent(Nonce, SourceToken, Moved, WorldTime, tracksPhase2: true, Phase2Saved, preMergeStack, destroysSource);
		}

		public string Format()
		{
			string text = string.Join(";", TracksPhase2 ? "v2" : "v1", Nonce, SourceToken, Moved.ToString(CultureInfo.InvariantCulture), WorldTime.ToString("R", CultureInfo.InvariantCulture));
			if (!TracksPhase2)
			{
				return text;
			}
			text = text + ";" + (Phase2Saved ? "1" : "0");
			if (!PreMergeStack.HasValue)
			{
				return text;
			}
			return text + ";" + PreMergeStack.Value.ToString(CultureInfo.InvariantCulture) + ";" + ((DestroysSource == true) ? "d" : "s");
		}

		public static MergeIntent? Parse(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			string[] array = text.Split(';');
			if (array.Length == 5 && array[0] == "v1")
			{
				return From(array, tracksPhase2: false, phase2Saved: false, null, null);
			}
			if (array.Length == 6 && array[0] == "v2" && Flag(array[5]))
			{
				return From(array, tracksPhase2: true, array[5] == "1", null, null);
			}
			if (array.Length == 8 && array[0] == "v2" && Flag(array[5]) && (array[7] == "d" || array[7] == "s") && int.TryParse(array[6], NumberStyles.None, CultureInfo.InvariantCulture, out var result) && result > 0)
			{
				return From(array, tracksPhase2: true, array[5] == "1", result, array[7] == "d");
			}
			return null;
		}

		private static bool Flag(string text)
		{
			if (!(text == "0"))
			{
				return text == "1";
			}
			return true;
		}

		public static string AppendNonce(string? record, string nonce)
		{
			if (!ValidField(nonce) || nonce.IndexOf(',') >= 0)
			{
				throw new ArgumentException("Nonce must be non-empty and contain no ';' or ','.", "nonce");
			}
			List<string> list = new List<string>(Split(record));
			if (list.Contains(nonce))
			{
				return string.Join(",", list);
			}
			list.Add(nonce);
			if (list.Count > 8)
			{
				list.RemoveRange(0, list.Count - 8);
			}
			return string.Join(",", list);
		}

		public static bool HasNonce(string? record, string nonce)
		{
			return Array.IndexOf(Split(record), nonce) >= 0;
		}

		private static MergeIntent? From(string[] parts, bool tracksPhase2, bool phase2Saved, int? preMergeStack, bool? destroysSource)
		{
			if (!ValidField(parts[1]) || !ValidField(parts[2]))
			{
				return null;
			}
			if (!int.TryParse(parts[3], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result <= 0)
			{
				return null;
			}
			if (!double.TryParse(parts[4], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || double.IsNaN(result2) || double.IsInfinity(result2))
			{
				return null;
			}
			return new MergeIntent(parts[1], parts[2], result, result2, tracksPhase2, phase2Saved, preMergeStack, destroysSource);
		}

		private static string[] Split(string? record)
		{
			if (!string.IsNullOrEmpty(record))
			{
				return record.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			}
			return Array.Empty<string>();
		}

		private static bool ValidField(string? value)
		{
			if (!string.IsNullOrEmpty(value))
			{
				return value.IndexOf(';') < 0;
			}
			return false;
		}
	}
	public enum MergeStep
	{
		EnsureSourceToken,
		WriteTarget,
		AwaitBarrier,
		DestroySource,
		ReduceSource,
		ClearIntent
	}
	public sealed class MergePlan
	{
		private readonly MergeStep[] steps;

		public GroundItem Target { get; }

		public GroundItem Source { get; }

		public int Moved { get; }

		public string Nonce { get; }

		public double WorldTime { get; }

		public int TargetStackAfter => Target.Stack + Moved;

		public int SourceStackAfter => Source.Stack - Moved;

		public bool DestroysSource => SourceStackAfter == 0;

		public double TargetSpawnTimeAfter => Math.Max(Target.SpawnTime, Source.SpawnTime);

		public bool NeedsSourceToken => string.IsNullOrEmpty(Source.Token);

		public IReadOnlyList<MergeStep> Steps => steps;

		internal MergePlan(GroundItem target, GroundItem source, int moved, string nonce, double worldTime)
		{
			Target = target;
			Source = source;
			Moved = moved;
			Nonce = nonce;
			WorldTime = worldTime;
			List<MergeStep> list = new List<MergeStep>();
			if (NeedsSourceToken)
			{
				list.Add(MergeStep.EnsureSourceToken);
			}
			list.Add(MergeStep.WriteTarget);
			list.Add(MergeStep.AwaitBarrier);
			list.Add(DestroysSource ? MergeStep.DestroySource : MergeStep.ReduceSource);
			list.Add(MergeStep.ClearIntent);
			steps = list.ToArray();
		}

		public MergeIntent Intent(string sourceToken)
		{
			return new MergeIntent(Nonce, sourceToken, Moved, WorldTime).WithBaseline(Target.Stack, DestroysSource);
		}
	}
	public static class MergePlanner
	{
		private sealed class SpatialGroup
		{
			private readonly double cellSize;

			private readonly List<(GroundItem Item, int Order)> all = new List<(GroundItem, int)>();

			private List<(GroundItem Item, int Order)>? unindexed;

			private Dictionary<(int X, int Y, int Z), List<(GroundItem Item, int Order)>>? cells;

			internal SpatialGroup(float radius)
			{
				cellSize = 2.0 * (double)radius;
			}

			internal void Add(GroundItem item, int order)
			{
				all.Add((item, order));
			}

			internal GroundItem? Source(GroundItem target, float radiusSquared, HashSet<long> used, int minimum, out int nearby)
			{
				nearby = 0;
				if (all.Count < minimum)
				{
					return null;
				}
				GroundItem source = null;
				int sourceOrder = int.MaxValue;
				if (!Cell(target.Position, out (int, int, int) cell))
				{
					foreach (var item in all)
					{
						Consider(item, target, radiusSquared, used, ref nearby, ref source, ref sourceOrder);
					}
					return source;
				}
				if (cells == null)
				{
					cells = new Dictionary<(int, int, int), List<(GroundItem, int)>>();
					unindexed = new List<(GroundItem, int)>();
					foreach (var item2 in all)
					{
						if (!Cell(item2.Item.Position, out (int, int, int) cell2))
						{
							unindexed.Add(item2);
							continue;
						}
						if (!cells.TryGetValue(cell2, out List<(GroundItem, int)> value))
						{
							cells.Add(cell2, value = new List<(GroundItem, int)>());
						}
						value.Add(item2);
					}
				}
				for (int i = -1; i <= 1; i++)
				{
					for (int j = -1; j <= 1; j++)
					{
						for (int k = -1; k <= 1; k++)
						{
							if (!cells.TryGetValue((cell.Item1 + i, cell.Item2 + j, cell.Item3 + k), out List<(GroundItem, int)> value2))
							{
								continue;
							}
							foreach (var item3 in value2)
							{
								Consider(item3, target, radiusSquared, used, ref nearby, ref source, ref sourceOrder);
							}
						}
					}
				}
				foreach (var item4 in unindexed)
				{
					Consider(item4, target, radiusSquared, used, ref nearby, ref source, ref sourceOrder);
				}
				return source;
			}

			private static void Consider((GroundItem Item, int Order) entry, GroundItem target, float radiusSquared, HashSet<long> used, ref int nearby, ref GroundItem? source, ref int sourceOrder)
			{
				var (groundItem, _) = entry;
				if (groundItem.Id != target.Id && groundItem.Position.DistanceSquared(target.Position) <= radiusSquared)
				{
					nearby++;
					if (!used.Contains(groundItem.Id) && groundItem.Stack < groundItem.MaxStack && (source == null || groundItem.Stack < source.Stack || (groundItem.Stack == source.Stack && (groundItem.Created > source.Created || (groundItem.Created == source.Created && (groundItem.Id > source.Id || (groundItem.Id == source.Id && entry.Order < sourceOrder)))))))
					{
						source = groundItem;
						sourceOrder = entry.Order;
					}
				}
			}

			private bool Cell(Point3 position, out (int X, int Y, int Z) cell)
			{
				double num = Math.Floor((double)position.X / cellSize);
				double num2 = Math.Floor((double)position.Y / cellSize);
				double num3 = Math.Floor((double)position.Z / cellSize);
				cell = default((int, int, int));
				if (!(num > -2147483648.0) || !(num < 2147483647.0) || !(num2 > -2147483648.0) || !(num2 < 2147483647.0) || !(num3 > -2147483648.0) || !(num3 < 2147483647.0))
				{
					return false;
				}
				cell = (X: (int)num, Y: (int)num2, Z: (int)num3);
				return true;
			}
		}

		private static readonly ItemIdentityKey Keys = new ItemIdentityKey();

		public static IReadOnlyList<MergePlan> Plan(IReadOnlyList<GroundItem> items, MergeSettings settings, double worldTime, Func<string> nonce)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			if (settings == null)
			{
				throw new ArgumentNullException("settings");
			}
			if (nonce == null)
			{
				throw new ArgumentNullException("nonce");
			}
			List<(GroundItem, string)> list = (from item in items
				where item != null && Eligible(item, settings)
				select (Item: item, Key: Keys.Key(item.Identity)) into entry
				where entry.Key != null
				orderby entry.Item.Stack descending, entry.Item.Created, entry.Item.Id
				select entry).ToList();
			Dictionary<string, SpatialGroup> dictionary = null;
			bool flag = false;
			float radiusSquared = settings.Radius * settings.Radius;
			HashSet<long> used = new HashSet<long>();
			List<MergePlan> list2 = new List<MergePlan>();
			foreach (var target in list)
			{
				if (list2.Count >= settings.MaxMergesPerScan)
				{
					break;
				}
				if (used.Contains(target.Item1.Id) || target.Item1.Stack >= target.Item1.MaxStack)
				{
					continue;
				}
				if (flag && dictionary == null)
				{
					dictionary = new Dictionary<string, SpatialGroup>(StringComparer.Ordinal);
					for (int num = 0; num < list.Count; num++)
					{
						(GroundItem, string) tuple = list[num];
						if (!dictionary.TryGetValue(tuple.Item2, out var value))
						{
							dictionary.Add(tuple.Item2, value = new SpatialGroup(settings.Radius));
						}
						value.Add(tuple.Item1, num);
					}
				}
				GroundItem groundItem;
				int nearby;
				if (dictionary != null)
				{
					groundItem = dictionary[target.Item2].Source(target.Item1, radiusSquared, used, settings.MinCount, out nearby);
				}
				else
				{
					List<GroundItem> list3 = (from other in list
						where other.Item.Id != target.Item1.Id && string.Equals(other.Key, target.Item2, StringComparison.Ordinal) && other.Item.Position.DistanceSquared(target.Item1.Position) <= radiusSquared
						select other.Item).ToList();
					nearby = list3.Count;
					groundItem = ((nearby + 1 < settings.MinCount) ? null : (from other in list3
						where !used.Contains(other.Id) && other.Stack < other.MaxStack
						orderby other.Stack, other.Created descending, other.Id descending
						select other).FirstOrDefault());
				}
				if (nearby + 1 < settings.MinCount || groundItem == null)
				{
					flag = list.Count > 64;
					continue;
				}
				int num2 = Math.Min(groundItem.Stack, target.Item1.MaxStack - target.Item1.Stack);
				if (num2 > 0)
				{
					used.Add(target.Item1.Id);
					used.Add(groundItem.Id);
					list2.Add(new MergePlan(target.Item1, groundItem, num2, nonce(), worldTime));
				}
			}
			return list2;
		}

		public static bool Eligible(GroundItem item, MergeSettings settings)
		{
			if (item.Valid && item.OwnedLocally && item.MaxStack > 1 && item.Stack > 0 && !item.Moving && !item.Pulled && !item.PendingIntent && item.AgeSeconds >= settings.SettleSeconds && item.Identity != null)
			{
				return !settings.Ignores(item.Identity.Prefab);
			}
			return false;
		}
	}
	public enum SourceObservation
	{
		NotFound,
		FoundWithoutNonce,
		FoundWithNonce
	}
	public enum ReconcileAction
	{
		Wait,
		RollBackTarget,
		Clear,
		FinishDestroy
	}
	public static class MergeReconcile
	{
		public const double ReconcileAfterSeconds = 10.0;

		public const double BarrierTimeoutSeconds = 10.0;

		public const double ClearAfterSeconds = 60.0;

		public const float SearchMargin = 2f;

		public static ReconcileAction Decide(MergeIntent intent, double now, bool areaReady, SourceObservation source)
		{
			if (intent.Phase2Saved && intent.DestroysSource == true && source == SourceObservation.FoundWithoutNonce)
			{
				return ReconcileAction.FinishDestroy;
			}
			if (!areaReady || now - intent.WorldTime < 10.0)
			{
				return ReconcileAction.Wait;
			}
			if (source == SourceObservation.FoundWithNonce || intent.Phase2Saved)
			{
				return ReconcileAction.Clear;
			}
			if (intent.TracksPhase2 || source == SourceObservation.FoundWithoutNonce)
			{
				return ReconcileAction.RollBackTarget;
			}
			return ReconcileAction.Clear;
		}

		public static int StackAfterRollback(int savedStack, int moved, int? preMergeStack)
		{
			if (savedStack < 1)
			{
				savedStack = 1;
			}
			if (moved < 1)
			{
				return savedStack;
			}
			if (!preMergeStack.HasValue)
			{
				return Math.Max(1, savedStack - moved);
			}
			int value = preMergeStack.Value;
			int num = value + moved;
			if (savedStack == num)
			{
				return Math.Max(1, savedStack - moved);
			}
			int num2 = savedStack - moved;
			if (num2 >= value)
			{
				return num2;
			}
			return Math.Max(1, Math.Min(savedStack, value));
		}

		public static float SearchRadius(MergeSettings settings)
		{
			return settings.Radius + 2f;
		}
	}
	public sealed class MergeSettings
	{
		public const float DefaultRadius = 3f;

		public const int DefaultMinCount = 2;

		public const int DefaultMaxMergesPerScan = 2;

		public const double DefaultSettleSeconds = 2.0;

		private readonly HashSet<string> ignore;

		public float Radius { get; }

		public int MinCount { get; }

		public int MaxMergesPerScan { get; }

		public double SettleSeconds { get; }

		public MergeSettings(float radius = 3f, int minCount = 2, int maxMergesPerScan = 2, double settleSeconds = 2.0, IEnumerable<string>? ignore = null)
		{
			Radius = ((float.IsNaN(radius) || float.IsInfinity(radius)) ? 3f : Math.Min(10f, Math.Max(0.5f, radius)));
			MinCount = Math.Min(20, Math.Max(2, minCount));
			MaxMergesPerScan = Math.Min(20, Math.Max(1, maxMergesPerScan));
			SettleSeconds = ((double.IsNaN(settleSeconds) || double.IsInfinity(settleSeconds)) ? 2.0 : Math.Min(30.0, Math.Max(0.0, settleSeconds)));
			this.ignore = new HashSet<string>(from name in ignore ?? Enumerable.Empty<string>()
				select (name ?? "").Trim() into name
				where name.Length > 0
				select name, StringComparer.OrdinalIgnoreCase);
		}

		public bool Ignores(string prefab)
		{
			return ignore.Contains(prefab ?? "");
		}
	}
}
namespace ExtraPotions.Magpie.Loot
{
	public enum LootSource
	{
		Unknown,
		Creature,
		Destructible,
		RockOrTree,
		Pickable,
		Spawner,
		PlayerDrop,
		ContainerSpill,
		TombstoneSpill,
		PieceRefund,
		StationOutput,
		ShipSpill
	}
	[Flags]
	public enum LootSources
	{
		None = 0,
		Creatures = 1,
		Destructibles = 2,
		Pickables = 4,
		Spawners = 8,
		Default = 0xF
	}
	public readonly struct LootExtra
	{
		public int Amount { get; }

		public LootExtra(int amount)
		{
			Amount = amount;
		}
	}
	public static class LootPolicy
	{
		public const int MinMultiplier = 1;

		public const int MaxMultiplier = 20;

		public static bool IsWorldLoot(LootSource source)
		{
			if ((uint)(source - 1) <= 4u)
			{
				return true;
			}
			return false;
		}

		public static LootSources FlagFor(LootSource source)
		{
			switch (source)
			{
			case LootSource.Creature:
				return LootSources.Creatures;
			case LootSource.Destructible:
			case LootSource.RockOrTree:
				return LootSources.Destructibles;
			case LootSource.Pickable:
				return LootSources.Pickables;
			case LootSource.Spawner:
				return LootSources.Spawners;
			default:
				return LootSources.None;
			}
		}

		public static bool ShouldMark(LootSource source, LootSources enabled, int multiplier, float wildbloodCreatureMultiplier)
		{
			if (ClampMultiplier(multiplier) <= 1 || !IsWorldLoot(source))
			{
				return false;
			}
			LootSources lootSources = FlagFor(source);
			if ((enabled & lootSources) != lootSources)
			{
				return false;
			}
			if (source == LootSource.Creature && wildbloodCreatureMultiplier > 1f)
			{
				return false;
			}
			return true;
		}

		public static int EffectiveMultiplier(int configured, bool allowed)
		{
			if (!allowed)
			{
				return 1;
			}
			return ClampMultiplier(configured);
		}

		public static int Picked(int before, int after)
		{
			return Math.Max(0, after - before);
		}

		public static bool ExtraCheated(bool takenCheated)
		{
			return takenCheated;
		}

		public static int ClampMultiplier(int multiplier)
		{
			return Math.Min(20, Math.Max(1, multiplier));
		}

		public static LootExtra Extra(bool marked, int maxStack, int pickedAmount, int multiplier, bool stackableOnly)
		{
			int num = ClampMultiplier(multiplier);
			if (!marked || num <= 1 || pickedAmount <= 0 || (stackableOnly && maxStack <= 1))
			{
				return new LootExtra(0);
			}
			long num2 = (long)pickedAmount * (long)(num - 1);
			return new LootExtra((int)((num2 > int.MaxValue) ? int.MaxValue : num2));
		}

		public static IReadOnlyList<int> SplitIntoStacks(int amount, int maxStack)
		{
			int num = Math.Max(1, maxStack);
			List<int> list = new List<int>();
			for (int num2 = Math.Max(0, amount); num2 > 0; num2 -= num)
			{
				list.Add(Math.Min(num, num2));
			}
			return list;
		}

		public static int OverflowDrop(bool added, int stackLeft)
		{
			if (added || stackLeft <= 0)
			{
				return 0;
			}
			return stackLeft;
		}
	}
}
namespace ExtraPotions.Magpie.Items
{
	public static class CheatedMark
	{
		public const MagpieModule Modules = MagpieModule.Pickup | MagpieModule.Merge | MagpieModule.Loot;

		public static bool Active(MagpieModule on)
		{
			return (on & (MagpieModule.Pickup | MagpieModule.Merge | MagpieModule.Loot)) != 0;
		}

		public static int? OnSave(bool active, bool cheated, int stored)
		{
			if (!active || !cheated || stored == 1)
			{
				return null;
			}
			return 1;
		}

		public static bool OnLoad(bool active, bool cheated, int stored)
		{
			if (!cheated)
			{
				if (active)
				{
					return stored == 1;
				}
				return false;
			}
			return true;
		}
	}
	public interface IItemIdentityKey<TItem>
	{
		string? Key(TItem? item);

		bool Same(TItem? left, TItem? right);
	}
	public sealed class ItemIdentity
	{
		private readonly KeyValuePair<string, string>[] customData;

		public string Prefab { get; }

		public int Quality { get; }

		public int Variant { get; }

		public long CrafterId { get; }

		public string CrafterName { get; }

		public float Durability { get; }

		public int WorldLevel { get; }

		public IReadOnlyList<KeyValuePair<string, string>> CustomData => customData;

		public bool Cheated { get; }

		public bool Loot { get; }

		public bool IsValid
		{
			get
			{
				if (!string.IsNullOrWhiteSpace(Prefab) && Quality >= 0 && Variant >= 0 && WorldLevel >= 0 && !float.IsNaN(Durability))
				{
					return !float.IsInfinity(Durability);
				}
				return false;
			}
		}

		public ItemIdentity(string prefab, int quality, int variant, long crafterId, string crafterName, float durability, int worldLevel, IReadOnlyDictionary<string, string>? customData, bool cheated, bool loot)
		{
			Prefab = prefab ?? "";
			Quality = quality;
			Variant = variant;
			CrafterId = crafterId;
			CrafterName = crafterName ?? "";
			Durability = ((durability == 0f) ? 0f : durability);
			WorldLevel = worldLevel;
			this.customData = (customData ?? new Dictionary<string, string>()).Select<KeyValuePair<string, string>, KeyValuePair<string, string>>((KeyValuePair<string, string> pair) => new KeyValuePair<string, string>(pair.Key ?? "", pair.Value ?? "")).OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Key, StringComparer.Ordinal).ToArray();
			Cheated = cheated;
			Loot = loot;
		}

		internal string? CanonicalKey()
		{
			if (!IsValid)
			{
				return null;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			List<string> values = new List<string>
			{
				"v1",
				"p=" + Escape(Prefab),
				"q=" + Quality.ToString(invariantCulture),
				"v=" + Variant.ToString(invariantCulture),
				"ci=" + CrafterId.ToString(invariantCulture),
				"cn=" + Escape(CrafterName),
				"d=" + BitConverter.SingleToInt32Bits(Durability).ToString("x8", invariantCulture),
				"wl=" + WorldLevel.ToString(invariantCulture),
				"ch=" + (Cheated ? "1" : "0"),
				"lt=" + (Loot ? "1" : "0"),
				"cd=" + string.Join(",", customData.Select((KeyValuePair<string, string> pair) => Escape(pair.Key) + "=" + Escape(pair.Value)))
			};
			return string.Join(";", values);
		}

		private static string Escape(string value)
		{
			return value.Replace("\\", "\\\\").Replace(";", "\\;").Replace(",", "\\,")
				.Replace("=", "\\=");
		}
	}
	public sealed class ItemIdentityKey : IItemIdentityKey<ItemIdentity>
	{
		public string? Key(ItemIdentity? item)
		{
			return item?.CanonicalKey();
		}

		public bool Same(ItemIdentity? left, ItemIdentity? right)
		{
			string text = Key(left);
			if (text != null)
			{
				return string.Equals(text, Key(right), StringComparison.Ordinal);
			}
			return false;
		}
	}
}
namespace ExtraPotions.Magpie.Conversion
{
	public enum ImportSource
	{
		SwiftPickup,
		FloatingItems,
		LegacyFloatingItems
	}
	public sealed class ImportPlan
	{
		public ImportSource Source { get; }

		public IReadOnlyDictionary<string, object> Values { get; }

		public IReadOnlyList<string> Notes { get; }

		internal ImportPlan(ImportSource source, IDictionary<string, object> values, IList<string> notes)
		{
			Source = source;
			Values = new ReadOnlyDictionary<string, object>(new Dictionary<string, object>(values, StringComparer.Ordinal));
			Notes = Array.AsReadOnly(notes.ToArray());
		}

		public override string ToString()
		{
			return string.Join("\n", new string[1] { "Source: " + Source }.Concat(Values.Select<KeyValuePair<string, object>, string>((KeyValuePair<string, object> pair) => "Set " + pair.Key + " = " + Convert.ToString(pair.Value, CultureInfo.InvariantCulture))).Concat(Notes));
		}
	}
	public static class SourceImport
	{
		private const string MeadworksMenuKey = "F8";

		public static string FileName(ImportSource source)
		{
			return source switch
			{
				ImportSource.SwiftPickup => "user.swiftpickup.cfg", 
				ImportSource.FloatingItems => "com.ab5olutezer0.valheim.floatingitems.cfg", 
				ImportSource.LegacyFloatingItems => "com.michal.valheim.floatingitems.cfg", 
				_ => throw new ArgumentOutOfRangeException("source"), 
			};
		}

		public static string SourceId(ImportSource source)
		{
			return source switch
			{
				ImportSource.SwiftPickup => "user.swiftpickup", 
				ImportSource.FloatingItems => "com.ab5olutezer0.valheim.floatingitems", 
				ImportSource.LegacyFloatingItems => "com.michal.valheim.floatingitems", 
				_ => throw new ArgumentOutOfRangeException("source"), 
			};
		}

		private static SettingSpec? Setting(ImportSource source, string key)
		{
			if (source != ImportSource.SwiftPickup)
			{
				if (!(key == "General.ExcludedItems"))
				{
					return null;
				}
				return MagpieSettings.ExcludedItems;
			}
			return key switch
			{
				"General.Enabled" => MagpieSettings.AutoPickupAtStart, 
				"General.PickupRange" => MagpieSettings.PickupRange, 
				"General.ScanIntervalSeconds" => MagpieSettings.ScanInterval, 
				"General.MaxPickupsPerScan" => MagpieSettings.MaxPickupsPerScan, 
				"General.MagnetSpeed" => MagpieSettings.MagnetSpeed, 
				"General.IgnoreItems" => MagpieSettings.IgnoreItems, 
				"General.ToggleKey" => MagpieSettings.PickupToggleKey, 
				"Loot.LootMultiplier" => MagpieSettings.LootMultiplier, 
				"Merge.MergeNearbyDrops" => MagpieSettings.MergeEnabled, 
				"Merge.MergeRadius" => MagpieSettings.MergeRadius, 
				"Merge.MergeMinCount" => MagpieSettings.MergeMinCount, 
				"Merge.MaxMergesPerScan" => MagpieSettings.MaxMergesPerScan, 
				"Performance.SkipPickupEffects" => MagpieSettings.SkipPickupEffects, 
				"Performance.ShowPickupMessages" => MagpieSettings.ShowPickupMessages, 
				_ => null, 
			};
		}

		public static ImportPlan Plan(ImportSource source, string text)
		{
			FileName(source);
			if (text == null || text.Length > 1048576)
			{
				throw new ArgumentException("Import source exceeds 1 MiB or is missing.");
			}
			Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal);
			List<string> list = new List<string>();
			string text2 = "";
			string[] array = text.Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text3 = array[i].Trim().TrimStart('\ufeff');
				if (text3.Length == 0 || text3[0] == '#' || text3[0] == ';')
				{
					continue;
				}
				if (text3[0] == '[' && text3[text3.Length - 1] == ']')
				{
					text2 = text3.Substring(1, text3.Length - 2).Trim();
					continue;
				}
				int num = text3.IndexOf('=');
				if (num <= 0)
				{
					list.Add("Skipped unrecognized source line.");
					continue;
				}
				string text4 = text2 + "." + text3.Substring(0, num).Trim();
				string text5 = text3.Substring(num + 1).Trim();
				SettingSpec settingSpec = Setting(source, text4);
				if (settingSpec == null)
				{
					list.Add("Skipped unknown key: " + text4);
					continue;
				}
				if (dictionary.ContainsKey(settingSpec.Id))
				{
					throw new FormatException("Duplicate source setting: " + text4);
				}
				object value;
				if (settingSpec.Default is bool)
				{
					if (!bool.TryParse(text5, out var result))
					{
						throw new FormatException("Invalid boolean: " + text4);
					}
					value = result;
				}
				else if (settingSpec.Default is int)
				{
					if (!long.TryParse(text5, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
					{
						throw new FormatException("Invalid integer: " + text4);
					}
					int num2 = (int)Math.Max(settingSpec.Minimum.Value, Math.Min(settingSpec.Maximum.Value, result2));
					if (num2 != result2)
					{
						list.Add("Clamped " + text4 + " to " + num2.ToString(CultureInfo.InvariantCulture));
					}
					value = num2;
				}
				else if (settingSpec.Default is float)
				{
					if (!double.TryParse(text5, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) || double.IsNaN(result3) || double.IsInfinity(result3))
					{
						throw new FormatException("Invalid finite number: " + text4);
					}
					float num3 = (float)Math.Max(settingSpec.Minimum.Value, Math.Min(settingSpec.Maximum.Value, result3));
					if (result3 < settingSpec.Minimum.Value || result3 > settingSpec.Maximum.Value)
					{
						list.Add("Clamped " + text4 + " to " + num3.ToString("R", CultureInfo.InvariantCulture));
					}
					value = num3;
				}
				else if (settingSpec == MagpieSettings.PickupToggleKey && string.Equals(text5, "F8", StringComparison.OrdinalIgnoreCase))
				{
					value = "";
					list.Add("Pickup Toggle Key left unbound: F8 is the Meadworks menu key.");
				}
				else
				{
					value = text5;
				}
				dictionary.Add(settingSpec.Id, value);
			}
			return new ImportPlan(source, dictionary, list);
		}
	}
}
namespace ExtraPotions.Magpie.Config
{
	public static class MagpieSettings
	{
		private const string General = "1 - General";

		private const string Pickup = "2 - Pickup";

		private const string Messages = "3 - Messages";

		private const string Merge = "4 - Merge";

		private const string Float = "5 - Float";

		private const string Cheats = "6 - Cheats";

		private const string Interface = "7 - Interface";

		private const SettingScope L = SettingScope.Local;

		private const SettingScope SA = SettingScope.ServerAuthoritative;

		private const SettingScope C = SettingScope.Cheat;

		public static readonly SettingSpec Enabled = new SettingSpec("1 - General", "Enabled", SettingScope.ServerAuthoritative, true, "Turns all of Magpie on or off. Off: the game's own auto pickup runs and no item is merged, floated or marked.");

		public static readonly SettingSpec PickupEnabled = new SettingSpec("1 - General", "Pickup Enabled", SettingScope.ServerAuthoritative, true, "Magpie pickup (fast, smooth magnet). Off: the game's own auto pickup runs.");

		public static readonly SettingSpec MergeEnabled = new SettingSpec("1 - General", "Merge Enabled", SettingScope.ServerAuthoritative, true, "Identical items lying near each other merge into one stack.");

		public static readonly SettingSpec FloatEnabled = new SettingSpec("1 - General", "Float Enabled", SettingScope.ServerAuthoritative, true, "Dropped items float on water and tar like wood. A change also applies to items already lying in the world.");

		public static readonly SettingSpec AutoPickupAtStart = new SettingSpec("2 - Pickup", "Auto Pickup At Start", SettingScope.Local, true, "Auto pickup state when the game starts; the game's auto pickup key (and the optional toggle key) changes it in play.");

		public static readonly SettingSpec PickupRange = new SettingSpec("2 - Pickup", "Pickup Range", SettingScope.Local, 3.5f, "Radius in meters around the player in which items glide in. The server's Max Pickup Range caps it; range bonuses from other mods still scale it.", 0.5, 20.0);

		public static readonly SettingSpec MagnetSpeed = new SettingSpec("2 - Pickup", "Magnet Speed", SettingScope.Local, 15f, "Speed in meters per second at which items glide to the player (the game uses 15).", 1.0, 50.0);

		public static readonly SettingSpec ScanInterval = new SettingSpec("2 - Pickup", "Scan Interval", SettingScope.Local, 0.15f, "Seconds between searches for items in range.", 0.05, 1.0);

		public static readonly SettingSpec MaxPickupsPerScan = new SettingSpec("2 - Pickup", "Max Pickups Per Scan", SettingScope.Local, 2, "Items taken per search at most; 0 means no limit. Never more than one item per frame.", 0.0, 20.0);

		public static readonly SettingSpec IgnoreItems = new SettingSpec("2 - Pickup", "Ignore Items", SettingScope.Local, "", "Comma-separated prefab names that are never picked up automatically (picking them up by hand still works).");

		public static readonly SettingSpec MaxPickupRange = new SettingSpec("2 - Pickup", "Max Pickup Range", SettingScope.ServerAuthoritative, 10f, "Largest Pickup Range any player may use, in meters.", 2.0, 20.0);

		public static readonly SettingSpec ShowPickupMessages = new SettingSpec("3 - Messages", "Show Pickup Messages", SettingScope.Local, true, "Shows the top-left message for each item taken automatically.");

		public static readonly SettingSpec GroupPickupMessages = new SettingSpec("3 - Messages", "Group Pickup Messages", SettingScope.Local, true, "Items of the same kind taken within one second show as one line with the summed amount.");

		public static readonly SettingSpec SkipPickupEffects = new SettingSpec("3 - Messages", "Skip Pickup Effects", SettingScope.Local, true, "No particles or sound for each item taken automatically.");

		public static readonly SettingSpec MergeRadius = new SettingSpec("4 - Merge", "Merge Radius", SettingScope.ServerAuthoritative, 3f, "Distance in meters within which identical items merge.", 0.5, 10.0);

		public static readonly SettingSpec MergeMinCount = new SettingSpec("4 - Merge", "Merge Min Count", SettingScope.ServerAuthoritative, 2, "Identical items needed within the radius before they merge.", 2.0, 20.0);

		public static readonly SettingSpec MaxMergesPerScan = new SettingSpec("4 - Merge", "Max Merges Per Scan", SettingScope.ServerAuthoritative, 2, "Merges started per scan at most.", 1.0, 20.0);

		public static readonly SettingSpec MergeScanInterval = new SettingSpec("4 - Merge", "Merge Scan Interval", SettingScope.ServerAuthoritative, 0.5f, "Seconds between merge scans.", 0.1, 5.0);

		public static readonly SettingSpec MergeSettleTime = new SettingSpec("4 - Merge", "Merge Settle Time", SettingScope.ServerAuthoritative, 2f, "Seconds an item must lie still before it may merge.", 0.0, 30.0);

		public static readonly SettingSpec MergeIgnoreItems = new SettingSpec("4 - Merge", "Merge Ignore Items", SettingScope.ServerAuthoritative, "", "Comma-separated prefab names that never merge.");

		public static readonly SettingSpec ExcludedItems = new SettingSpec("5 - Float", "Excluded Items", SettingScope.ServerAuthoritative, "", "Comma-separated prefab names that keep sinking, for example \"Coins, IronScrap\". A change also applies to items already lying in the world.");

		public static readonly SettingSpec LootMultiplier = new SettingSpec("6 - Cheats", "Loot Multiplier", SettingScope.Cheat, 1, "Cheat: world loot you pick up is multiplied by this number (1 = off). Only drops from creatures, destructibles, rocks, trees, pickables and loot spawners; the extras are not marked as cheated. In multiplayer the server decides.", 1.0, 20.0);

		public static readonly SettingSpec LootSources = new SettingSpec("6 - Cheats", "Loot Sources", SettingScope.Cheat, ExtraPotions.Magpie.Loot.LootSources.Default, "Cheat: which kinds of world loot the multiplier applies to. Player drops, chest and tombstone spills, refunds and station output never count.");

		public static readonly SettingSpec StackableOnly = new SettingSpec("6 - Cheats", "Stackable Only", SettingScope.Cheat, true, "Cheat: only stackable loot is multiplied; weapons, armor and other single items stay one item.");

		public static readonly SettingSpec PickupToggleKey = new SettingSpec("7 - Interface", "Pickup Toggle Key", SettingScope.Local, "", "Optional key that turns auto pickup on or off, like the game's own auto pickup key. Merging and the loot multiplier are not affected.", null, null, shortcut: true);

		public static readonly SettingSpec PickupTogglePadChord = new SettingSpec("7 - Interface", "Pickup Toggle Pad Chord", SettingScope.Local, "", "Optional gamepad chord that toggles auto pickup, for example LB+X. Unbound by default; typing and game windows block it. Merging and loot are unaffected.");

		public static readonly SettingSpec LockedPlayerSettings = new SettingSpec("7 - Interface", "Locked Player Settings", SettingScope.ServerAuthoritative, "", "Comma-separated Magpie Local setting IDs (Section.Key) that the server forces to its own values. Empty: personal settings remain independent.");

		public static IReadOnlyList<SettingSpec> All { get; } = new SettingSpec[27]
		{
			Enabled, PickupEnabled, MergeEnabled, FloatEnabled, AutoPickupAtStart, PickupRange, MagnetSpeed, ScanInterval, MaxPickupsPerScan, IgnoreItems,
			MaxPickupRange, ShowPickupMessages, GroupPickupMessages, SkipPickupEffects, MergeRadius, MergeMinCount, MaxMergesPerScan, MergeScanInterval, MergeSettleTime, MergeIgnoreItems,
			ExcludedItems, LootMultiplier, LootSources, StackableOnly, PickupToggleKey, PickupTogglePadChord, LockedPlayerSettings
		};

		public static SettingSpec? Find(string? id)
		{
			if (id != null)
			{
				return All.FirstOrDefault((SettingSpec setting) => string.Equals(setting.Id, id.Trim(), StringComparison.OrdinalIgnoreCase));
			}
			return null;
		}
	}
	public sealed class NameList
	{
		public static readonly NameList Empty = new NameList(new HashSet<string>(StringComparer.OrdinalIgnoreCase));

		private readonly HashSet<string> names;

		public int Count => names.Count;

		public IEnumerable<string> Names => names;

		private NameList(HashSet<string> names)
		{
			this.names = names;
		}

		public bool Contains(string? name)
		{
			string text = (name ?? "").Trim();
			if (text.Length > 0)
			{
				return names.Contains(text);
			}
			return false;
		}

		public static NameList Parse(string? text)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					hashSet.Add(text2);
				}
			}
			if (hashSet.Count != 0)
			{
				return new NameList(hashSet);
			}
			return Empty;
		}
	}
	public static class PickupRadius
	{
		public static float Effective(float pickupRange, float maxPickupRange, float currentPlayerRange, float basePlayerRange)
		{
			float val = MagpieSettings.PickupRange.Clamp(pickupRange);
			float val2 = MagpieSettings.MaxPickupRange.Clamp(maxPickupRange);
			return Math.Min(val, val2) * Factor(currentPlayerRange, basePlayerRange);
		}

		public static float Factor(float current, float baseRange)
		{
			if (!Usable(current) || !Usable(baseRange))
			{
				return 1f;
			}
			return current / baseRange;
		}

		private static bool Usable(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return value > 0f;
			}
			return false;
		}
	}
	public sealed class LockList
	{
		private readonly HashSet<string> locked;

		public static LockList Empty { get; } = new LockList(Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>());

		public IReadOnlyList<string> Locked { get; }

		public IReadOnlyList<string> Unknown { get; }

		public IReadOnlyList<string> NotLockable { get; }

		private LockList(IReadOnlyList<string> lockedIds, IReadOnlyList<string> unknown, IReadOnlyList<string> notLockable)
		{
			Locked = lockedIds;
			Unknown = unknown;
			NotLockable = notLockable;
			locked = new HashSet<string>(lockedIds, StringComparer.OrdinalIgnoreCase);
		}

		public static LockList Parse(string? text)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0)
				{
					SettingSpec settingSpec = MagpieSettings.Find(text2);
					List<string> list4 = ((settingSpec == null) ? list2 : (settingSpec.Lockable ? list : list3));
					string text3 = settingSpec?.Id ?? text2;
					if (!list4.Contains<string>(text3, StringComparer.OrdinalIgnoreCase))
					{
						list4.Add(text3);
					}
				}
			}
			if (list.Count + list2.Count + list3.Count != 0)
			{
				return new LockList(list, list2, list3);
			}
			return Empty;
		}

		public bool IsLocked(string? id)
		{
			if (id != null)
			{
				return locked.Contains(id.Trim());
			}
			return false;
		}

		public string Describe()
		{
			string text = Locked.Count + " locked";
			if (Unknown.Count > 0)
			{
				text = text + "; unknown: " + string.Join(", ", Unknown);
			}
			if (NotLockable.Count > 0)
			{
				text = text + "; not lockable: " + string.Join(", ", NotLockable);
			}
			return text;
		}
	}
	public static class LockedValues
	{
		public static string Encode(IEnumerable<KeyValuePair<string, string>> values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			return string.Join(";", values.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> v) => Escape(v.Key) + "=" + Escape(v.Value ?? "")));
		}

		public static IReadOnlyDictionary<string, string> Decode(string? text)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrEmpty(text))
			{
				return dictionary;
			}
			foreach (string item in Split(text, ';'))
			{
				List<string> list = Split(item, '=').ToList();
				if (list.Count == 2)
				{
					string text2 = Unescape(list[0]);
					string text3 = Unescape(list[1]);
					if (!string.IsNullOrWhiteSpace(text2) && text3 != null && !dictionary.ContainsKey(text2.Trim()))
					{
						dictionary.Add(text2.Trim(), text3);
					}
				}
			}
			return dictionary;
		}

		public static string Compose(LockList list, Func<string, string?> ownText)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (ownText == null)
			{
				throw new ArgumentNullException("ownText");
			}
			return Encode(from id in list.Locked
				select new KeyValuePair<string, string>(id, ownText(id)) into p
				where p.Value != null
				select new KeyValuePair<string, string>(p.Key, p.Value));
		}

		private static string Escape(string text)
		{
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			foreach (char c in text)
			{
				if (c == '\\' || c == ';' || c == '=')
				{
					stringBuilder.Append('\\');
				}
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString();
		}

		private static IEnumerable<string> Split(string text, char separator)
		{
			int num = 0;
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] == '\\')
				{
					i++;
				}
				else if (text[i] == separator)
				{
					yield return text.Substring(num, i - num);
					num = i + 1;
				}
			}
			yield return text.Substring(num);
		}

		private static string? Unescape(string text)
		{
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] == '\\' && ++i >= text.Length)
				{
					return null;
				}
				stringBuilder.Append(text[i]);
			}
			return stringBuilder.ToString();
		}
	}
	public readonly struct PlayerLock
	{
		public bool Locked { get; }

		public string? ServerText { get; }

		public PlayerLock(bool locked, string? serverText)
		{
			Locked = locked;
			ServerText = (locked ? serverText : null);
		}

		public override string ToString()
		{
			if (!Locked)
			{
				return "Own";
			}
			return "Locked (" + ServerText + ")";
		}
	}
	public static class PlayerLocks
	{
		public static PlayerLock Evaluate(string id, bool serverBinds, LockList list, IReadOnlyDictionary<string, string> values)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (!serverBinds || !list.IsLocked(id) || !values.TryGetValue(id.Trim(), out string value))
			{
				return new PlayerLock(locked: false, null);
			}
			return new PlayerLock(locked: true, value);
		}
	}
	public enum SettingScope
	{
		Local,
		ServerAuthoritative,
		Cheat
	}
	public sealed class SettingSpec
	{
		public string Section { get; }

		public string Key { get; }

		public string Id => Section + "." + Key;

		public SettingScope Scope { get; }

		public bool Lockable => Scope == SettingScope.Local;

		public object Default { get; }

		public Type ValueType => Default.GetType();

		public double? Minimum { get; }

		public double? Maximum { get; }

		public string Description { get; }

		public bool Shortcut { get; }

		public SettingSpec(string section, string key, SettingScope scope, object defaultValue, string description, double? minimum = null, double? maximum = null, bool shortcut = false)
		{
			Section = section;
			Key = key;
			Scope = scope;
			Default = defaultValue ?? throw new ArgumentNullException("defaultValue");
			Description = description;
			Minimum = minimum;
			Maximum = maximum;
			Shortcut = shortcut;
		}

		public T Clamp<T>(T value)
		{
			if (value is float)
			{
				object obj = value;
				float num = (float)((obj is float) ? obj : null);
				if (float.IsNaN(num) || float.IsInfinity(num))
				{
					return (T)Default;
				}
				return (T)(object)(float)Limit(num);
			}
			if (value is int)
			{
				object obj2 = value;
				int num2 = (int)((obj2 is int) ? obj2 : null);
				return (T)(object)(int)Limit(num2);
			}
			return value;
		}

		private double Limit(double value)
		{
			if (Minimum.HasValue && value < Minimum.Value)
			{
				value = Minimum.Value;
			}
			if (Maximum.HasValue && value > Maximum.Value)
			{
				value = Maximum.Value;
			}
			return value;
		}
	}
}