using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using ExtraPotions.Delve.Config;
using ExtraPotions.Delve.Conversion;
using ExtraPotions.Delve.Data;
using ExtraPotions.Delve.Engine;
using ExtraPotions.Delve.Regrow;
using ExtraPotions.Delve.Surface;
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.15.0")]
[assembly: AssemblyInformationalVersion("0.1.15")]
[assembly: AssemblyProduct("Delve.Core")]
[assembly: AssemblyTitle("Delve.Core")]
[assembly: AssemblyVersion("0.1.15.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.Delve
{
	public static class DelveCore
	{
		public const string PluginGuid = "com.meadworks.delve";

		public const string ProductName = "Delve";

		public const string ProductVersion = "0.1.15";

		public const string Family = "Runestone";

		public const string TokenNamespace = "delve";

		public const string TokenPrefix = "meadworks_delve_";

		public const string ZdoPrefix = "delve.";

		public const string InstanceKey = "delve.instance";

		public const string SupportedGameVersion = "1.0.17";
	}
}
namespace ExtraPotions.Delve.Surface
{
	public enum SurfaceScope
	{
		Resources,
		Nature,
		All
	}
	public enum SurfaceClass
	{
		None,
		Tree,
		Bush,
		Mineable,
		Pickable
	}
	public enum SurfaceSpot
	{
		Present,
		Base,
		Location,
		Player,
		Restore
	}
	public sealed class SurfaceFacts
	{
		public Vec3 Spot { get; }

		public bool Present { get; }

		public float BaseClearance { get; }

		public IReadOnlyList<Vec3> Built { get; set; } = Array.Empty<Vec3>();

		public IReadOnlyList<Area> Bases { get; set; } = Array.Empty<Area>();

		public IReadOnlyList<Area> Locations { get; set; } = Array.Empty<Area>();

		public IReadOnlyList<Vec3> Players { get; set; } = Array.Empty<Vec3>();

		public SurfaceFacts(Vec3 spot, bool present, float baseClearance)
		{
			if (!(baseClearance >= 0f) || float.IsInfinity(baseClearance))
			{
				throw new ArgumentException("Expected a finite clearance of 0 or more.", "baseClearance");
			}
			Spot = spot;
			Present = present;
			BaseClearance = baseClearance;
		}
	}
	public static class SurfaceRules
	{
		public const float MatchRadius = 0.75f;

		public const float PlayerRadius = 3f;

		public const float StubRadius = 1.5f;

		public const double LayoutShare = 0.75;

		public const float InteriorGap = 1000f;

		public static bool InScope(SurfaceScope scope, SurfaceClass kind)
		{
			if (kind == SurfaceClass.None)
			{
				return false;
			}
			switch (scope)
			{
			case SurfaceScope.Resources:
				if (kind != SurfaceClass.Mineable)
				{
					return kind == SurfaceClass.Pickable;
				}
				return true;
			case SurfaceScope.Nature:
				if (kind != SurfaceClass.Tree)
				{
					return kind == SurfaceClass.Bush;
				}
				return true;
			default:
				return true;
			}
		}

		public static SurfaceClass Classify(bool tree, bool mineable, bool pickable, bool destructible, bool excluded)
		{
			if (excluded)
			{
				return SurfaceClass.None;
			}
			if (tree)
			{
				return SurfaceClass.Tree;
			}
			if (mineable)
			{
				return SurfaceClass.Mineable;
			}
			if (pickable)
			{
				return SurfaceClass.Pickable;
			}
			if (!destructible)
			{
				return SurfaceClass.None;
			}
			return SurfaceClass.Bush;
		}

		public static SurfaceSpot Decide(SurfaceFacts facts)
		{
			if (facts == null)
			{
				throw new ArgumentNullException("facts");
			}
			if (facts.Present)
			{
				return SurfaceSpot.Present;
			}
			if (BuiltWithin(facts.Spot, facts.BaseClearance, facts.Built) || facts.Bases.Any((Area a) => a.Contains(facts.Spot)))
			{
				return SurfaceSpot.Base;
			}
			if (facts.Locations.Any((Area a) => a.Contains(facts.Spot)))
			{
				return SurfaceSpot.Location;
			}
			if (facts.Players.Any((Vec3 p) => Vec3.Flat(p, facts.Spot) < 3f))
			{
				return SurfaceSpot.Player;
			}
			return SurfaceSpot.Restore;
		}

		public static bool BuiltWithin(Vec3 spot, float clearance, IEnumerable<Vec3> built)
		{
			if (clearance <= 0f || built == null)
			{
				return false;
			}
			foreach (Vec3 item in built)
			{
				if (Vec3.Flat(item, spot) < clearance && Math.Abs(item.Y - spot.Y) < 1000f)
				{
					return true;
				}
			}
			return false;
		}

		public static bool Matches(Vec3 generated, Vec3 standing)
		{
			return Vec3.Flat(generated, standing) < 0.75f;
		}

		public static bool LayoutMatches(int standing, int matched)
		{
			if (standing > 0)
			{
				return (double)matched >= Math.Ceiling((double)standing * 0.75);
			}
			return true;
		}

		public static IReadOnlyList<(int X, int Z)> ZonesWithin(Vec3 center, float radius)
		{
			(int X, int Z) home = RegrowRules.Zone(center);
			int num = (int)Math.Ceiling(radius / 64f) + 1;
			List<(int, int)> list = new List<(int, int)>();
			for (int i = -num; i <= num; i++)
			{
				for (int j = -num; j <= num; j++)
				{
					(int, int) tuple = (home.X + i, home.Z + j);
					if (RegrowRules.ZoneNear(tuple, center, radius))
					{
						list.Add(tuple);
					}
				}
			}
			return (from z in list
				orderby Math.Abs(z.X - home.X) + Math.Abs(z.Z - home.Z), z.X, z.Z
				select z).ToList();
		}
	}
	public sealed class SurfaceReport
	{
		public SurfaceScope Scope { get; }

		public bool DryRun { get; }

		public int Zones { get; set; }

		public int ZonesSkipped { get; set; }

		public int Restored { get; set; }

		public int Stubs { get; set; }

		public int Diverged { get; private set; }

		public SortedSet<string> DivergedNames { get; } = new SortedSet<string>(StringComparer.Ordinal);

		public Dictionary<SurfaceSpot, int> Held { get; } = new Dictionary<SurfaceSpot, int>();

		public SortedDictionary<string, int> ByPrefab { get; } = new SortedDictionary<string, int>(StringComparer.Ordinal);

		public SurfaceReport(SurfaceScope scope, bool dryRun)
		{
			Scope = scope;
			DryRun = dryRun;
		}

		public void Diverge(string prefab)
		{
			Diverged++;
			DivergedNames.Add(prefab);
		}

		public IReadOnlyList<string> Lines()
		{
			string text = ((Scope == SurfaceScope.Resources) ? "resources" : ((Scope == SurfaceScope.Nature) ? "nature" : "resources and nature"));
			List<string> list = new List<string>();
			list.Add("Delve surface reset (" + text + ")" + (DryRun ? ", dry run: nothing was changed" : "") + ": " + N(Restored) + (DryRun ? " would come back" : " came back") + " in " + N(Zones) + " zones" + ((Stubs > 0) ? (", " + N(Stubs) + " stumps cleared") : "") + ".");
			List<string> list2 = list;
			List<string> list3 = new List<string>();
			if (Held.TryGetValue(SurfaceSpot.Base, out var value) && value > 0)
			{
				list3.Add(N(value) + " inside the base clearance");
			}
			if (Held.TryGetValue(SurfaceSpot.Location, out var value2) && value2 > 0)
			{
				list3.Add(N(value2) + " inside locations");
			}
			if (Held.TryGetValue(SurfaceSpot.Player, out var value3) && value3 > 0)
			{
				list3.Add(N(value3) + " next to a player");
			}
			if (list3.Count > 0)
			{
				list2.Add("Held back: " + string.Join(", ", list3) + ".");
			}
			if (ZonesSkipped > 0)
			{
				list2.Add(N(ZonesSkipped) + " zones in range are not generated or not loaded on the server and were left out.");
			}
			if (Diverged > 0)
			{
				list2.Add(N(Diverged) + " object layouts no longer match their zone and were left as they are (" + string.Join(", ", DivergedNames) + ").");
			}
			return list2;
		}

		private static string N(int value)
		{
			return value.ToString(CultureInfo.InvariantCulture);
		}
	}
}
namespace ExtraPotions.Delve.Rooms
{
	public readonly struct RoomCounts : IEquatable<RoomCounts>
	{
		public int Min { get; }

		public int Max { get; }

		public RoomCounts(int min, int max)
		{
			Min = min;
			Max = max;
		}

		public bool Equals(RoomCounts other)
		{
			if (Min == other.Min)
			{
				return Max == other.Max;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return Min * 1009 + Max;
		}

		public override string ToString()
		{
			return Min + "/" + Max;
		}
	}
	public readonly struct RoomOverride
	{
		public bool Enabled { get; }

		public int Min { get; }

		public int Max { get; }

		public RoomOverride(bool enabled, int min, int max)
		{
			Enabled = enabled;
			Min = min;
			Max = max;
		}
	}
	public sealed class RoomSettings
	{
		public bool Enabled { get; }

		public int Min { get; }

		public int Max { get; }

		public RoomOverride ForestCrypt { get; }

		public RoomOverride SunkenCrypt { get; }

		public RoomOverride Cave { get; }

		public RoomSettings(bool enabled, int min, int max, RoomOverride forestCrypt, RoomOverride sunkenCrypt, RoomOverride cave)
		{
			Enabled = enabled;
			Min = min;
			Max = max;
			ForestCrypt = forestCrypt;
			SunkenCrypt = sunkenCrypt;
			Cave = cave;
		}
	}
	public static class RoomRules
	{
		public const int MinFloor = 10;

		public const int MinCap = 120;

		public const int MaxCap = 1000;

		public const string ForestCrypt = "DG_ForestCrypt";

		public const string SunkenCrypt = "DG_SunkenCrypt";

		public const string Cave = "DG_Cave";

		public static IReadOnlyList<string> ConfigGenerators { get; } = Array.AsReadOnly(new string[3] { "DG_ForestCrypt", "DG_SunkenCrypt", "DG_Cave" });

		public static IReadOnlyList<string> VanillaGenerators { get; } = Array.AsReadOnly(new string[14]
		{
			"DG_AshlandRuins", "DG_Cave", "DG_DvergrBoss", "DG_DvergrTown", "DG_ForestCrypt", "DG_FortressRuins", "DG_GoblinCamp", "DG_HalfBurried_ForestCrypt", "DG_Hole", "DG_MeadowsFarm",
			"DG_MeadowsVillage", "DG_MorkHalla", "DG_NorthVillage", "DG_SunkenCrypt"
		});

		public static bool Protected(string generator)
		{
			return generator?.StartsWith("DG_Hildir_", StringComparison.Ordinal) ?? false;
		}

		public static RoomCounts Clamp(int min, int max)
		{
			int num = Math.Min(120, Math.Max(10, min));
			int val = Math.Min(1000, Math.Max(10, max));
			return new RoomCounts(num, Math.Max(num, val));
		}

		public static RoomCounts? Effective(string generator, RoomSettings settings, RoomsFile file)
		{
			if (settings == null)
			{
				throw new ArgumentNullException("settings");
			}
			if (file == null)
			{
				throw new ArgumentNullException("file");
			}
			if (!settings.Enabled || string.IsNullOrEmpty(generator) || Protected(generator))
			{
				return null;
			}
			switch (generator)
			{
			case "DG_ForestCrypt":
				return Pick(settings.ForestCrypt, settings);
			case "DG_SunkenCrypt":
				return Pick(settings.SunkenCrypt, settings);
			case "DG_Cave":
				return Pick(settings.Cave, settings);
			default:
			{
				if (file.Overrides.TryGetValue(generator, out var value))
				{
					return Clamp(value.Min, value.Max);
				}
				if (!VanillaGenerators.Contains(generator))
				{
					return null;
				}
				return Clamp(settings.Min, settings.Max);
			}
			}
		}

		public static IReadOnlyList<string> Unknown(RoomsFile file, IEnumerable<string> knownGenerators)
		{
			HashSet<string> known = new HashSet<string>(knownGenerators ?? Enumerable.Empty<string>(), StringComparer.Ordinal);
			return file.Overrides.Keys.Where((string g) => !known.Contains(g)).OrderBy<string, string>((string g) => g, StringComparer.Ordinal).ToArray();
		}

		private static RoomCounts Pick(RoomOverride o, RoomSettings s)
		{
			if (!o.Enabled)
			{
				return Clamp(s.Min, s.Max);
			}
			return Clamp(o.Min, o.Max);
		}
	}
	public sealed class RoomsFile
	{
		public static RoomsFile Empty { get; } = new RoomsFile(new Dictionary<string, RoomCounts>(), Array.Empty<string>());

		public IReadOnlyDictionary<string, RoomCounts> Overrides { get; }

		public IReadOnlyList<string> Errors { get; }

		private RoomsFile(IReadOnlyDictionary<string, RoomCounts> overrides, IReadOnlyList<string> errors)
		{
			Overrides = overrides;
			Errors = errors;
		}

		public static RoomsFile Parse(string? text)
		{
			List<string> list = new List<string>();
			Dictionary<string, RoomCounts> dictionary = new Dictionary<string, RoomCounts>(StringComparer.Ordinal);
			if (MiniYaml.Read(text, list).TryGetValue("overrides", out IReadOnlyList<YamlEntry> value))
			{
				foreach (YamlEntry item in value)
				{
					if (item.Map == null || !item.Map.TryGetValue("min", out string value2) || !item.Map.TryGetValue("max", out string value3) || !int.TryParse(value2, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !int.TryParse(value3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
					{
						list.Add("line " + item.Line + ": '" + item.Name + "' needs {min: <whole number>, max: <whole number>}");
					}
					else if (RoomRules.Protected(item.Name))
					{
						list.Add("line " + item.Line + ": '" + item.Name + "' is never changed (Hildir's dungeons keep their size)");
					}
					else if (RoomRules.ConfigGenerators.Contains(item.Name))
					{
						list.Add("line " + item.Line + ": '" + item.Name + "' is set in the Rooms section of the config; this entry is ignored");
					}
					else
					{
						dictionary[item.Name] = new RoomCounts(result, result2);
					}
				}
			}
			return new RoomsFile(dictionary, list);
		}
	}
}
namespace ExtraPotions.Delve.Respawn
{
	public sealed class RespawnOptions
	{
		public static RespawnOptions Defaults { get; } = new RespawnOptions(camps: false, 5.0, dungeons: false, 7.0);

		public bool Camps { get; }

		public double CampDays { get; }

		public bool Dungeons { get; }

		public double DungeonDays { get; }

		public RespawnOptions(bool camps, double campDays, bool dungeons, double dungeonDays)
		{
			Camps = camps;
			CampDays = campDays;
			Dungeons = dungeons;
			DungeonDays = dungeonDays;
		}
	}
	public enum RespawnApproach
	{
		ArmLocal,
		ServerReset
	}
	public enum SpawnerReset
	{
		Leave,
		Waiting,
		Blocked,
		Reset
	}
	public static class SpawnerRules
	{
		public const float InteriorHeight = 3000f;

		public static double MinutesFor(bool inDungeon, RespawnOptions options, double daySeconds)
		{
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			double num = daySeconds / 60.0;
			if (inDungeon)
			{
				if (!options.Dungeons)
				{
					return 0.0;
				}
				return Math.Max(0.0, options.DungeonDays) * num;
			}
			if (!options.Camps)
			{
				return 0.0;
			}
			return Math.Max(0.0, options.CampDays) * num;
		}

		public static float? Arm(float currentMinutes, bool hasSpawned, double minutes)
		{
			if (currentMinutes > 0f || !hasSpawned)
			{
				return null;
			}
			if (!(minutes > 0.0))
			{
				return null;
			}
			return (float)minutes;
		}

		public static RespawnApproach Approach(bool authorityOwnsSpawner)
		{
			if (!authorityOwnsSpawner)
			{
				return RespawnApproach.ServerReset;
			}
			return RespawnApproach.ArmLocal;
		}

		public static RespawnApproach PathFor(bool loadedAndOwned, ClockKind clock)
		{
			if (!loadedAndOwned || clock != ClockKind.InGameDays)
			{
				return RespawnApproach.ServerReset;
			}
			return RespawnApproach.ArmLocal;
		}

		public static double ArmMinutes(double days, double daySeconds)
		{
			return ClockRules.Clamp(ClockKind.InGameDays, days) * daySeconds / 60.0;
		}

		public static Stamp LastAlive(long aliveTicks, double daySeconds)
		{
			return WorldClock.FromGameTicks(aliveTicks, daySeconds);
		}

		public static bool InDungeon(Vec3 position)
		{
			return position.Y > 3000f;
		}

		public static SpawnerReset ServerReset(bool oneShot, bool hasSpawned, bool creatureAlive, Stamp lastAlive, Stamp now, ClockKind clock, double delay, GuardInput guard)
		{
			GuardResult blockedBy;
			return ServerReset(oneShot, hasSpawned, creatureAlive, lastAlive, now, clock, delay, guard, out blockedBy);
		}

		public static SpawnerReset ServerReset(bool oneShot, bool hasSpawned, bool creatureAlive, Stamp lastAlive, Stamp now, ClockKind clock, double delay, GuardInput guard, out GuardResult blockedBy)
		{
			if (guard == null)
			{
				throw new ArgumentNullException("guard");
			}
			blockedBy = GuardResult.Clear;
			if (!oneShot || !hasSpawned || creatureAlive)
			{
				return SpawnerReset.Leave;
			}
			if (!ClockRules.Due(clock, delay, lastAlive.CompletedWith(now), now))
			{
				return SpawnerReset.Waiting;
			}
			blockedBy = Guards.Evaluate(guard);
			if (blockedBy != GuardResult.Clear)
			{
				return SpawnerReset.Blocked;
			}
			return SpawnerReset.Reset;
		}
	}
}
namespace ExtraPotions.Delve.Reset
{
	public enum FullResetOutcome
	{
		FirstSight,
		Waiting,
		PlayerInside,
		Tombstone,
		Built,
		PlayerBase,
		Reset
	}
	public enum WipeAction
	{
		Keep,
		Remove
	}
	public static class FullResetRules
	{
		public readonly struct ResetCommit
		{
			public bool RemoveOld { get; }

			public bool RemoveCreated { get; }

			private ResetCommit(bool removeOld, bool removeCreated)
			{
				RemoveOld = removeOld;
				RemoveCreated = removeCreated;
			}

			public static ResetCommit For(bool replacementReady)
			{
				if (!replacementReady)
				{
					return new ResetCommit(removeOld: false, removeCreated: true);
				}
				return new ResetCommit(removeOld: true, removeCreated: false);
			}

			public static long[] Surviving(IReadOnlyList<long> oldIds, IReadOnlyList<long> createdIds, bool replacementReady)
			{
				if (oldIds == null)
				{
					throw new ArgumentNullException("oldIds");
				}
				if (createdIds == null)
				{
					throw new ArgumentNullException("createdIds");
				}
				return (For(replacementReady).RemoveCreated ? oldIds : createdIds).ToArray();
			}
		}

		public const float Margin = 8f;

		public const bool NativeProbePassed = true;

		public const string Citadel = "DG_DvergrBoss";

		public static bool EffectiveDryRun(bool dryRun)
		{
			return dryRun;
		}

		public static FullResetOutcome Decide(Stamp? lastVisit, Stamp now, ClockKind clock, double delay, bool regenerateNow, bool playerInside, bool tombstoneInside, bool builtInside, bool buildClearance, bool inPlayerBase)
		{
			if (!lastVisit.HasValue && !regenerateNow)
			{
				return FullResetOutcome.FirstSight;
			}
			if (!regenerateNow && !ClockRules.Due(clock, delay, lastVisit.Value.CompletedWith(now), now))
			{
				return FullResetOutcome.Waiting;
			}
			if (playerInside)
			{
				return FullResetOutcome.PlayerInside;
			}
			if (tombstoneInside)
			{
				return FullResetOutcome.Tombstone;
			}
			if (builtInside && buildClearance)
			{
				return FullResetOutcome.Built;
			}
			if (inPlayerBase)
			{
				return FullResetOutcome.PlayerBase;
			}
			return FullResetOutcome.Reset;
		}

		public static bool RestoreQueen(string generator, bool queenInside, bool bossRoomFound)
		{
			return generator == "DG_DvergrBoss" && !queenInside && bossRoomFound;
		}

		public static bool RelockDoor(string generator, bool closeSealedDoor, bool doorFound)
		{
			return generator == "DG_DvergrBoss" && closeSealedDoor && doorFound;
		}

		public static WipeAction Wipe(bool isGenerator, bool isPlayer, bool isTombstone)
		{
			if (!(isGenerator || isPlayer || isTombstone))
			{
				return WipeAction.Remove;
			}
			return WipeAction.Keep;
		}

		public static Box Interior(Vec3 generator, Vec3 zoneSize, Vec3 zoneCenter)
		{
			float num = zoneSize.X / 2f + 8f;
			float num2 = zoneSize.Y / 2f + 8f;
			float num3 = zoneSize.Z / 2f + 8f;
			if (!(num > 0f) || !(num2 > 0f) || !(num3 > 0f))
			{
				throw new ArgumentException("Expected a positive zone size.", "zoneSize");
			}
			return new Box(new Vec3(zoneCenter.X - num, generator.Y - num2, zoneCenter.Z - num3), new Vec3(zoneCenter.X + num, generator.Y + num2, zoneCenter.Z + num3));
		}
	}
}
namespace ExtraPotions.Delve.Regrow
{
	public readonly struct DriftSpot
	{
		public int Id { get; }

		public Vec3 Position { get; }

		public DriftSpot(int id, Vec3 position)
		{
			Id = id;
			Position = position;
		}
	}
	public readonly struct DriftObject
	{
		public int Id { get; }

		public Vec3 Position { get; }

		public bool Whole { get; }

		public DriftObject(int id, Vec3 position, bool whole)
		{
			Id = id;
			Position = position;
			Whole = whole;
		}
	}
	public readonly struct DriftMove
	{
		public int SpotId { get; }

		public int ObjectId { get; }

		public DriftMove(int spotId, int objectId)
		{
			SpotId = spotId;
			ObjectId = objectId;
		}
	}
	public sealed class DriftSettlement
	{
		public IReadOnlyList<DriftMove> Moves { get; }

		public IReadOnlyList<int> NewObjects { get; }

		public bool BlockMissingRestore { get; }

		public DriftSettlement(IReadOnlyList<DriftMove> moves, IReadOnlyList<int> newObjects, bool blockMissingRestore)
		{
			Moves = moves ?? throw new ArgumentNullException("moves");
			NewObjects = newObjects ?? throw new ArgumentNullException("newObjects");
			BlockMissingRestore = blockMissingRestore;
		}
	}
	public static class DriftRules
	{
		public static DriftSettlement Settle(IReadOnlyList<DriftSpot> spots, IReadOnlyList<DriftObject> objects, float radius = 6f)
		{
			if (spots == null)
			{
				throw new ArgumentNullException("spots");
			}
			if (objects == null)
			{
				throw new ArgumentNullException("objects");
			}
			if (!(radius > 0f) || float.IsInfinity(radius))
			{
				throw new ArgumentException("Expected a positive drift radius.", "radius");
			}
			List<(int, int, float)> list = new List<(int, int, float)>();
			for (int i = 0; i < spots.Count; i++)
			{
				for (int j = 0; j < objects.Count; j++)
				{
					float num = Vec3.Flat(spots[i].Position, objects[j].Position);
					if (num < radius)
					{
						list.Add((i, j, num));
					}
				}
			}
			list.Sort(delegate((int Spot, int Object, float Distance) a, (int Spot, int Object, float Distance) b)
			{
				int num4 = a.Distance.CompareTo(b.Distance);
				if (num4 != 0)
				{
					return num4;
				}
				int num5 = a.Spot.CompareTo(b.Spot);
				return (num5 == 0) ? a.Object.CompareTo(b.Object) : num5;
			});
			bool[] array = new bool[spots.Count];
			bool[] array2 = new bool[objects.Count];
			foreach (var item in list)
			{
				if (!array[item.Item1] && !array2[item.Item2])
				{
					array[item.Item1] = true;
					array2[item.Item2] = true;
				}
			}
			List<int> list2 = new List<int>();
			for (int num2 = 0; num2 < spots.Count; num2++)
			{
				if (!array[num2])
				{
					list2.Add(num2);
				}
			}
			List<int> list3 = new List<int>();
			bool flag = false;
			for (int num3 = 0; num3 < objects.Count; num3++)
			{
				if (objects[num3].Whole)
				{
					flag = true;
				}
				if (!array2[num3])
				{
					list3.Add(num3);
				}
			}
			List<DriftMove> list4 = new List<DriftMove>();
			List<int> list5 = new List<int>();
			if (list2.Count == 1 && list3.Count == 1)
			{
				list4.Add(new DriftMove(spots[list2[0]].Id, objects[list3[0]].Id));
			}
			else if (list2.Count == 0)
			{
				foreach (int item2 in list3)
				{
					if (objects[item2].Whole)
					{
						list5.Add(objects[item2].Id);
					}
				}
			}
			bool blockMissingRestore = flag && list2.Count - list4.Count > 0;
			return new DriftSettlement(list4, list5, blockMissingRestore);
		}
	}
	public static class DungeonSites
	{
		public const float InteriorHeight = 3000f;

		public const float DoorSearch = 100f;

		public static int? InsideOf(Vec3 p, IReadOnlyList<Vec3> mine, IReadOnlyList<Vec3> others, float insideRadius)
		{
			if (p.Y < 3000f)
			{
				return null;
			}
			int? result = null;
			float num = insideRadius;
			for (int i = 0; i < mine.Count; i++)
			{
				float num2 = Vec3.Flat(p, mine[i]);
				if (num2 < num && Math.Abs(p.Y - mine[i].Y) < 500f)
				{
					result = i;
					num = num2;
				}
			}
			if (!result.HasValue)
			{
				return null;
			}
			foreach (Vec3 other in others)
			{
				if (other.Y > 3000f && Vec3.Flat(p, other) < num)
				{
					return null;
				}
			}
			return result;
		}

		public static int? EntranceOf(Vec3 p, IReadOnlyList<Vec3> entrances, float radius)
		{
			if (p.Y >= 3000f)
			{
				return null;
			}
			int? result = null;
			float num = radius;
			for (int i = 0; i < entrances.Count; i++)
			{
				float num2 = Vec3.Flat(p, entrances[i]);
				if (num2 < num)
				{
					result = i;
					num = num2;
				}
			}
			return result;
		}

		public static int? NearestDoor(Vec3 generator, IReadOnlyList<Vec3> doors)
		{
			int? result = null;
			float num = 100f;
			for (int i = 0; i < doors.Count; i++)
			{
				float num2 = Vec3.Flat(generator, doors[i]);
				if (num2 < num)
				{
					result = i;
					num = num2;
				}
			}
			return result;
		}
	}
	public sealed class WelcomeMemory
	{
		private readonly Dictionary<long, (string Site, int Stage)> told = new Dictionary<long, (string, int)>();

		public IEnumerable<long> Players => told.Keys;

		public bool Enter(long player, string site, int stage)
		{
			if (told.TryGetValue(player, out (string, int) value) && value.Item1 == site && stage <= value.Item2)
			{
				return false;
			}
			told[player] = (site, stage);
			return true;
		}

		public string? SiteOf(long player)
		{
			if (!told.TryGetValue(player, out (string, int) value))
			{
				return null;
			}
			return value.Item1;
		}

		public void Leave(long player)
		{
			told.Remove(player);
		}
	}
	public readonly struct PlacedRoom
	{
		public int Hash { get; }

		public Vec3 Position { get; }

		public Vec3 Euler { get; }

		public PlacedRoom(int hash, Vec3 position, Vec3 euler)
		{
			Hash = hash;
			Position = position;
			Euler = euler;
		}
	}
	public static class RoomData
	{
		public static IReadOnlyList<PlacedRoom> Parse(byte[]? data)
		{
			List<PlacedRoom> list = new List<PlacedRoom>();
			if (data == null || data.Length < 4)
			{
				return list;
			}
			using BinaryReader binaryReader = new BinaryReader(new MemoryStream(data));
			int num = binaryReader.ReadInt32();
			if (num < 0 || data.Length < 4 + (long)num * 28L)
			{
				return new List<PlacedRoom>();
			}
			for (int i = 0; i < num; i++)
			{
				list.Add(new PlacedRoom(binaryReader.ReadInt32(), new Vec3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle()), new Vec3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle())));
			}
			return list;
		}

		public static PlacedRoom? Find(IReadOnlyList<PlacedRoom> rooms, int hash)
		{
			foreach (PlacedRoom room in rooms)
			{
				if (room.Hash == hash)
				{
					return room;
				}
			}
			return null;
		}
	}
	public enum DungeonOutcome
	{
		FirstSight,
		BossAlive,
		NoBossPlace,
		Waiting,
		NothingTaken,
		Occupied,
		Regenerate
	}
	public static class DungeonRegrowRules
	{
		public static DungeonOutcome Decide(Stamp? lastVisit, Stamp now, ClockKind clock, double delay, bool regenerateNow, bool bossKind, bool bossAlive, bool bossPlaceKnown, int missing, bool occupied)
		{
			if (!lastVisit.HasValue && !regenerateNow)
			{
				return DungeonOutcome.FirstSight;
			}
			if (bossKind && bossAlive)
			{
				return DungeonOutcome.BossAlive;
			}
			if (bossKind && !bossPlaceKnown)
			{
				return DungeonOutcome.NoBossPlace;
			}
			if (!regenerateNow && !ClockRules.Due(clock, delay, lastVisit.Value.CompletedWith(now), now))
			{
				return DungeonOutcome.Waiting;
			}
			if (missing == 0 && !bossKind)
			{
				return DungeonOutcome.NothingTaken;
			}
			if (occupied)
			{
				return DungeonOutcome.Occupied;
			}
			return DungeonOutcome.Regenerate;
		}

		public static bool SpotClear(Vec3 spot, float clearance, IEnumerable<Vec3> playerBuilt)
		{
			return !WorldRules.BuiltNear(spot, clearance, playerBuilt);
		}

		public static int UnitsLeft(Stamp? lastVisit, Stamp now, ClockKind clock, double delay, bool inside)
		{
			if (inside || !lastVisit.HasValue)
			{
				return ClockRules.WholeUnitsLeft(ClockRules.Clamp(clock, delay));
			}
			return ClockRules.WholeUnitsLeft(ClockRules.Remaining(clock, delay, lastVisit.Value.CompletedWith(now), now));
		}
	}
	public static class KallRoom
	{
		public const string Location = "DN_Bossroom";

		public const string Boss = "FrozenKing";

		public const string Proxy = "LocationProxy";

		public static readonly IReadOnlyList<string> Phases = Array.AsReadOnly(new string[3] { "FrozenKing", "FrozenKing_p2", "FrozenKing_p3" });

		public static readonly Vec3 BossOffset = new Vec3(-50f, 5002f, 200.48f);

		public const float BossYaw = 180f;

		public const float InsideRadius = 40f;

		public const float EntranceRadius = 30f;

		public static (Vec3 Position, float Yaw) BossSpot(Vec3 location, float locationYaw)
		{
			double num = (double)locationYaw * Math.PI / 180.0;
			float num2 = (float)Math.Cos(num);
			float num3 = (float)Math.Sin(num);
			Vec3 bossOffset = BossOffset;
			Vec3 item = new Vec3(location.X + bossOffset.X * num2 + bossOffset.Z * num3, location.Y + bossOffset.Y, location.Z - bossOffset.X * num3 + bossOffset.Z * num2);
			float num4 = (locationYaw + 180f) % 360f;
			return (Position: item, Yaw: (num4 < 0f) ? (num4 + 360f) : num4);
		}

		public static bool Inside(Vec3 p, Vec3 bossSpot)
		{
			if (p.Y >= 3000f)
			{
				return Vec3.Flat(p, bossSpot) <= 40f;
			}
			return false;
		}

		public static bool AtEntrance(Vec3 p, Vec3 location)
		{
			if (p.Y < 3000f)
			{
				return Vec3.Flat(p, location) <= 30f;
			}
			return false;
		}

		public static DungeonOutcome Decide(Stamp? lastVisit, Stamp now, ClockKind clock, double delay, bool regenerateNow, bool bossAlive, bool occupied)
		{
			return DungeonRegrowRules.Decide(lastVisit, now, clock, delay, regenerateNow, bossKind: true, bossAlive, bossPlaceKnown: true, 0, occupied);
		}
	}
	public enum RestoreStyle
	{
		Respawn,
		Unpick
	}
	public sealed class KindInfo
	{
		public DelveKind Kind { get; }

		public string? Generator { get; }

		public IReadOnlyList<string> Whole { get; }

		public IReadOnlyList<string> DamagedSuffixes { get; }

		public string? Biome { get; }

		public bool Drifts { get; }

		public float EntranceRadius { get; }

		public float InsideRadius { get; }

		public RestoreStyle Style { get; }

		public string? RestockRegenSpotsKey { get; }

		public string? RestockRegenVisitKey { get; }

		internal HashSet<string> UnpickPrefabs { get; }

		internal KindInfo(DelveKind kind, string? generator, string[] whole, string[] damagedSuffixes, string? biome, bool drifts, float entranceRadius, float insideRadius, string? spotsKey, string? visitKey, string[]? unpick = null)
		{
			Kind = kind;
			Generator = generator;
			Whole = Array.AsReadOnly(whole);
			DamagedSuffixes = Array.AsReadOnly(damagedSuffixes);
			Biome = biome;
			Drifts = drifts;
			EntranceRadius = entranceRadius;
			InsideRadius = insideRadius;
			RestockRegenSpotsKey = spotsKey;
			RestockRegenVisitKey = visitKey;
			UnpickPrefabs = new HashSet<string>(unpick ?? Array.Empty<string>(), StringComparer.Ordinal);
			Style = ((UnpickPrefabs.Count == whole.Length && whole.Length != 0) ? RestoreStyle.Unpick : RestoreStyle.Respawn);
		}
	}
	public static class KindCatalog
	{
		public static class Citadel
		{
			public const string Boss = "SeekerQueen";

			public const string BossRoom = "dvergr_new_bossroom_ENTRANCE02";

			public const string Door = "dungeon_queen_door";

			public static readonly Vec3 BossOffset = new Vec3(2f, -24f, 0f);

			public const float BossYaw = 270f;
		}

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

		private static readonly KindInfo[] Kinds = new KindInfo[10]
		{
			new KindInfo(DelveKind.MudPiles, "DG_SunkenCrypt", new string[2] { "mudpile2", "mudpile" }, new string[1] { "_frac" }, null, drifts: false, 30f, 200f, "restockregen_mudspots", "restockregen_lastvisit"),
			new KindInfo(DelveKind.FrostCaveCrystals, "DG_Cave", new string[1] { "Pickable_MountainCaveCrystal" }, None, null, drifts: false, 50f, 200f, "restockregen_crystalspots", "restockregen_cavevisit"),
			new KindInfo(DelveKind.BlackCores, "DG_DvergrTown", new string[1] { "Pickable_BlackCoreStand" }, None, null, drifts: false, 50f, 200f, "restockregen_corespots", "restockregen_minevisit", new string[1] { "Pickable_BlackCoreStand" }),
			new KindInfo(DelveKind.Morkhalla, "DG_MorkHalla", new string[13]
			{
				"Morkhalla_Eye1", "Morkhalla_Eye2", "Morkhalla_Eye3", "Morkhalla_Eye4", "Morkhalla_Eye5_gemstone", "Morkhalla_Eye6_gemstone", "Morkhalla_Eye7_gemstone", "Morkhalla_Rubble1", "Morkhalla_Rubble2", "Morkhalla_Rubble3",
				"Morkhalla_Rubble4", "Pickable_MorkHallaTreasure", "BlackIce_Start"
			}, None, null, drifts: false, 50f, 200f, "restockregen_morkspots", "restockregen_morkvisit", new string[7] { "Morkhalla_Eye1", "Morkhalla_Eye2", "Morkhalla_Eye3", "Morkhalla_Eye4", "Morkhalla_Eye5_gemstone", "Morkhalla_Eye6_gemstone", "Morkhalla_Eye7_gemstone" }),
			new KindInfo(DelveKind.Hole, "DG_Hole", new string[3] { "elaking_trashpile", "Spawner_Hole", "Spawner_Hole_double" }, None, null, drifts: false, 40f, 150f, "restockregen_holespots", "restockregen_holevisit"),
			new KindInfo(DelveKind.AncientArmor, null, new string[4] { "giant_helmet1", "giant_helmet2", "giant_sword1", "giant_sword2" }, new string[1] { "_destruction" }, "Mistlands", drifts: false, 0f, 0f, null, null),
			new KindInfo(DelveKind.Obsidian, null, new string[1] { "MineRock_Obsidian" }, None, "Mountain", drifts: false, 0f, 0f, null, null),
			new KindInfo(DelveKind.Flametal, null, new string[1] { "LeviathanLava" }, None, "AshLands", drifts: true, 0f, 0f, null, null),
			new KindInfo(DelveKind.Ice, null, new string[2] { "IcePond_rock", "IceShore_1" }, new string[1] { "_frac" }, "DeepNorth", drifts: false, 0f, 0f, null, null),
			new KindInfo(DelveKind.Queen, "DG_DvergrBoss", new string[6] { "SeekerEgg", "blackmarble_creep_4x1x1", "blackmarble_creep_4x2x1", "blackmarble_creep_stair", "blackmarble_creep_slope_inverted_1x1x2", "blackmarble_creep_slope_inverted_2x2x1" }, None, null, drifts: false, 30f, 150f, "restockregen_citadelspots", "restockregen_citadelvisit")
		};

		private static readonly Lazy<Dictionary<string, (string Whole, KindInfo Kind)>> byPrefab = new Lazy<Dictionary<string, (string, KindInfo)>>(delegate
		{
			Dictionary<string, (string, KindInfo)> dictionary = new Dictionary<string, (string, KindInfo)>(StringComparer.Ordinal);
			KindInfo[] kinds = Kinds;
			foreach (KindInfo kindInfo in kinds)
			{
				foreach (string item in kindInfo.Whole)
				{
					dictionary[item] = (item, kindInfo);
					foreach (string damagedSuffix in kindInfo.DamagedSuffixes)
					{
						dictionary[item + damagedSuffix] = (item, kindInfo);
					}
				}
			}
			return dictionary;
		});

		public static IReadOnlyList<KindInfo> All { get; } = Array.AsReadOnly(Kinds);

		public static KindInfo Of(DelveKind kind)
		{
			return Kinds.FirstOrDefault((KindInfo k) => k.Kind == kind) ?? throw new ArgumentException(kind.ToString() + " has no regrow catalog entry.", "kind");
		}

		public static string? WholeOf(string prefab)
		{
			if (prefab == null || !byPrefab.Value.TryGetValue(prefab, out (string, KindInfo) value))
			{
				return null;
			}
			return value.Item1;
		}

		public static DelveKind? KindOf(string prefab)
		{
			if (prefab == null || !byPrefab.Value.TryGetValue(prefab, out (string, KindInfo) value))
			{
				return null;
			}
			return value.Item2.Kind;
		}

		public static RestoreStyle StyleOf(string prefab)
		{
			if (prefab == null || !byPrefab.Value.TryGetValue(prefab, out (string, KindInfo) value))
			{
				throw new ArgumentException(prefab + " is not tracked by Delve.", "prefab");
			}
			if (!value.Item2.UnpickPrefabs.Contains(value.Item1))
			{
				return RestoreStyle.Respawn;
			}
			return RestoreStyle.Unpick;
		}
	}
	public readonly struct RecordSpot
	{
		public int Prefab { get; }

		public Vec3 Position { get; }

		public Vec3 Rotation { get; }

		public RecordSpot(int prefab, Vec3 position, Vec3 rotation)
		{
			Prefab = prefab;
			Position = position;
			Rotation = rotation;
		}
	}
	public sealed class RecordFile
	{
		public IReadOnlyList<RecordSpot> Spots { get; }

		public IReadOnlyDictionary<(int, int), int> Visits { get; }

		public IReadOnlyList<string> Errors { get; }

		private RecordFile(IReadOnlyList<RecordSpot> spots, IReadOnlyDictionary<(int, int), int> visits, IReadOnlyList<string> errors)
		{
			Spots = spots;
			Visits = visits;
			Errors = errors;
		}

		public static RecordFile Parse(string? text)
		{
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			List<RecordSpot> list = new List<RecordSpot>();
			Dictionary<(int, int), int> dictionary = new Dictionary<(int, int), int>();
			List<string> list2 = new List<string>();
			string[] array = (text ?? "").Replace("\r\n", "\n").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i];
				if (text2.Length == 0 || text2.StartsWith("#"))
				{
					continue;
				}
				string[] array2 = text2.Split(' ');
				try
				{
					if (array2[0] == "S" && array2.Length == 8)
					{
						list.Add(new RecordSpot(int.Parse(array2[1], invariantCulture), new Vec3(float.Parse(array2[2], invariantCulture), float.Parse(array2[3], invariantCulture), float.Parse(array2[4], invariantCulture)), new Vec3(float.Parse(array2[5], invariantCulture), float.Parse(array2[6], invariantCulture), float.Parse(array2[7], invariantCulture))));
					}
					else if (array2[0] == "V" && array2.Length == 4)
					{
						dictionary[(int.Parse(array2[1], invariantCulture), int.Parse(array2[2], invariantCulture))] = int.Parse(array2[3], invariantCulture);
					}
					else
					{
						list2.Add("line " + (i + 1) + ": skipped: " + text2);
					}
				}
				catch (FormatException)
				{
					list2.Add("line " + (i + 1) + ": skipped: " + text2);
				}
				catch (OverflowException)
				{
					list2.Add("line " + (i + 1) + ": skipped: " + text2);
				}
			}
			return new RecordFile(list, dictionary, list2);
		}

		public static string Write(IEnumerable<RecordSpot> spots, IReadOnlyDictionary<(int, int), int> visits)
		{
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			StringBuilder stringBuilder = new StringBuilder("# Delve regrow records. S = spot (prefab x y z rx ry rz), V = zone last visited (zone x, zone y, day).\n");
			foreach (RecordSpot spot in spots)
			{
				stringBuilder.Append(string.Format(invariantCulture, "S {0} {1:R} {2:R} {3:R} {4:R} {5:R} {6:R}\n", spot.Prefab, spot.Position.X, spot.Position.Y, spot.Position.Z, spot.Rotation.X, spot.Rotation.Y, spot.Rotation.Z));
			}
			foreach (KeyValuePair<(int, int), int> item in from v in visits
				orderby v.Key.Item1, v.Key.Item2
				select v)
			{
				stringBuilder.Append(string.Format(invariantCulture, "V {0} {1} {2}\n", item.Key.Item1, item.Key.Item2, item.Value));
			}
			return stringBuilder.ToString();
		}
	}
	public static class DungeonSpots
	{
		public static byte[] Encode(IReadOnlyCollection<RecordSpot> spots)
		{
			if (spots == null)
			{
				throw new ArgumentNullException("spots");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write(1);
			binaryWriter.Write(spots.Count);
			foreach (RecordSpot spot in spots)
			{
				binaryWriter.Write(spot.Prefab);
				Write(binaryWriter, spot.Position);
				Write(binaryWriter, spot.Rotation);
			}
			binaryWriter.Flush();
			return memoryStream.ToArray();
		}

		public static IReadOnlyList<RecordSpot> Decode(byte[]? data)
		{
			List<RecordSpot> list = new List<RecordSpot>();
			if (data == null || data.Length < 8)
			{
				return list;
			}
			using BinaryReader binaryReader = new BinaryReader(new MemoryStream(data));
			if (binaryReader.ReadInt32() != 1)
			{
				return list;
			}
			int num = binaryReader.ReadInt32();
			if (num < 0 || data.Length < 8 + (long)num * 28L)
			{
				return new List<RecordSpot>();
			}
			for (int i = 0; i < num; i++)
			{
				list.Add(new RecordSpot(binaryReader.ReadInt32(), Read(binaryReader), Read(binaryReader)));
			}
			return list;
		}

		private static void Write(BinaryWriter w, Vec3 v)
		{
			w.Write(v.X);
			w.Write(v.Y);
			w.Write(v.Z);
		}

		private static Vec3 Read(BinaryReader r)
		{
			return new Vec3(r.ReadSingle(), r.ReadSingle(), r.ReadSingle());
		}
	}
	public enum SpotState
	{
		Whole,
		Damaged,
		Missing
	}
	public enum SpotOutcome
	{
		Whole,
		Waiting,
		Near,
		Built,
		Restore,
		Replace
	}
	public static class RegrowRules
	{
		public const float ZoneSize = 64f;

		public static bool IsWhole(bool wholePrefab, string? healthText, bool dead, bool anyChunkHit, bool drifts)
		{
			if (wholePrefab && string.IsNullOrEmpty(healthText) && !dead)
			{
				return !(drifts && anyChunkHit);
			}
			return false;
		}

		public static SpotOutcome Decide(SpotState state, int lastVisitDay, int today, int days, bool regenerateNow, GuardInput guard)
		{
			if (guard == null)
			{
				throw new ArgumentNullException("guard");
			}
			if (state == SpotState.Whole)
			{
				return SpotOutcome.Whole;
			}
			if (!regenerateNow && today - lastVisitDay < Math.Max(1, days))
			{
				return SpotOutcome.Waiting;
			}
			switch (Guards.Evaluate(new GuardInput(guard.Center, guard.PlayerRadius)
			{
				Interior = guard.Interior,
				Players = guard.Players,
				HeldByPlayer = (guard.HeldByPlayer && state == SpotState.Damaged),
				Clearance = guard.Clearance,
				Built = guard.Built,
				BaseGuard = false
			}))
			{
			case GuardResult.PlayerNear:
			case GuardResult.Held:
				return SpotOutcome.Near;
			case GuardResult.Built:
				return SpotOutcome.Built;
			default:
				if (state != SpotState.Damaged)
				{
					return SpotOutcome.Restore;
				}
				return SpotOutcome.Replace;
			}
		}

		public static SpotOutcome DecideAt(SpotState state, Stamp? lastVisit, Stamp now, ClockKind clock, double delay, bool regenerateNow, GuardInput guard)
		{
			if (guard == null)
			{
				throw new ArgumentNullException("guard");
			}
			if (state == SpotState.Whole)
			{
				return SpotOutcome.Whole;
			}
			if (!regenerateNow && (!lastVisit.HasValue || !ClockRules.Due(clock, delay, lastVisit.Value.CompletedWith(now), now)))
			{
				return SpotOutcome.Waiting;
			}
			return Decide(state, 0, 1, 1, regenerateNow: true, guard);
		}

		public static bool ZoneNear((int X, int Z) zone, Vec3 p, float radius)
		{
			float num = 32f;
			float num2 = Math.Max(0f, Math.Abs(p.X - (float)zone.X * 64f) - num);
			float num3 = Math.Max(0f, Math.Abs(p.Z - (float)zone.Z * 64f) - num);
			return num2 * num2 + num3 * num3 <= radius * radius;
		}

		public static (int X, int Z) Zone(Vec3 p)
		{
			return (X: (int)Math.Floor((p.X + 32f) / 64f), Z: (int)Math.Floor((p.Z + 32f) / 64f));
		}
	}
	public readonly struct Spot
	{
		public string Prefab { get; }

		public Vec3 Position { get; }

		public Vec3 Rotation { get; }

		public Spot(string prefab, Vec3 position, Vec3 rotation)
		{
			Prefab = prefab ?? throw new ArgumentNullException("prefab");
			Position = position;
			Rotation = rotation;
		}
	}
	public sealed class SpotIndex
	{
		public const float DriftRadius = 6f;

		private readonly Dictionary<(int, int, int), Spot> spots = new Dictionary<(int, int, int), Spot>();

		public int Count => spots.Count;

		public IEnumerable<Spot> Spots => spots.Values;

		public static (int, int, int) Key(Vec3 p)
		{
			return ((int)Math.Round(p.X * 10f, MidpointRounding.ToEven), (int)Math.Round(p.Y * 10f, MidpointRounding.ToEven), (int)Math.Round(p.Z * 10f, MidpointRounding.ToEven));
		}

		public (int, int, int)? KeyAt(Vec3 p, string wholePrefab, bool drifts)
		{
			if (drifts)
			{
				foreach (KeyValuePair<(int, int, int), Spot> spot in spots)
				{
					if (spot.Value.Prefab == wholePrefab && Vec3.Flat(spot.Value.Position, p) < 6f)
					{
						return spot.Key;
					}
				}
				return null;
			}
			(int, int, int) tuple = Key(p);
			if (spots.ContainsKey(tuple))
			{
				return tuple;
			}
			for (int i = -2; i <= 2; i++)
			{
				for (int j = -2; j <= 2; j++)
				{
					for (int k = -2; k <= 2; k++)
					{
						(int, int, int) tuple2 = (tuple.Item1 + i, tuple.Item2 + j, tuple.Item3 + k);
						if (spots.TryGetValue(tuple2, out var value) && Vec3.SqrDistance(value.Position, p) < 0.04f)
						{
							return tuple2;
						}
					}
				}
			}
			return null;
		}

		public bool Remember(Spot spot, bool drifts)
		{
			if (KeyAt(spot.Position, spot.Prefab, drifts).HasValue)
			{
				return false;
			}
			spots[Key(spot.Position)] = spot;
			return true;
		}

		public bool TryGet((int, int, int) key, out Spot spot)
		{
			return spots.TryGetValue(key, out spot);
		}
	}
}
namespace ExtraPotions.Delve.Localization
{
	public readonly struct TextKey
	{
		public string Key { get; }

		public int Arguments { get; }

		public IReadOnlyList<string> Named { get; }

		public TextKey(string key, int arguments, params string[] named)
		{
			Key = key;
			Arguments = arguments;
			Named = named.OrderBy<string, string>((string n) => n, StringComparer.Ordinal).ToArray();
		}
	}
	public static class DelveTextKeys
	{
		public const string DaysOne = "days_one";

		public const string DaysMany = "days_many";

		public const string HoursOne = "hours_one";

		public const string HoursMany = "hours_many";

		public const string ChestRefill = "chest_refill";

		public const string ChestRefillLeftovers = "chest_refill_leftovers";

		public const string ChestDue = "chest_due";

		public const string HistoryMany = "history_many";

		public const string HistoryOnce = "history_once";

		public const string HistoryYou = "history_you";

		public const string HistoryToday = "history_today";

		public const string HistoryYesterday = "history_yesterday";

		public const string HistoryDaysAgo = "history_days_ago";

		public const string ImportDone = "import_done";

		public const string ServerOnlyIdle = "server_only_idle";

		public static readonly IReadOnlyList<(DelveKind Kind, string Stem)> SiteKinds = Array.AsReadOnly(new(DelveKind, string)[8]
		{
			(DelveKind.MudPiles, "mudpiles"),
			(DelveKind.FrostCaveCrystals, "crystals"),
			(DelveKind.BlackCores, "blackcores"),
			(DelveKind.Morkhalla, "morkhalla"),
			(DelveKind.Hole, "hole"),
			(DelveKind.Queen, "queen"),
			(DelveKind.FullReset, "fullreset"),
			(DelveKind.Kall, "kall")
		});

		public static readonly IReadOnlyList<(DelveKind Kind, string Key)> BiomeKinds = Array.AsReadOnly(new(DelveKind, string)[4]
		{
			(DelveKind.AncientArmor, "biome_mistlands"),
			(DelveKind.Obsidian, "biome_mountain"),
			(DelveKind.Flametal, "biome_ashlands"),
			(DelveKind.Ice, "biome_deepnorth")
		});

		private static readonly Lazy<TextKey[]> all = new Lazy<TextKey[]>(delegate
		{
			List<TextKey> list = new List<TextKey>
			{
				new TextKey("step_aside_rooms", 1),
				new TextKey("step_aside_fullreset", 1),
				new TextKey("step_aside_chests", 1),
				new TextKey("step_aside_resources", 1),
				new TextKey("step_aside_respawn", 1),
				new TextKey("days_one", 0),
				new TextKey("days_many", 1),
				new TextKey("hours_one", 0),
				new TextKey("hours_many", 1),
				new TextKey("chest_refill", 1),
				new TextKey("chest_refill_leftovers", 1),
				new TextKey("chest_due", 0),
				new TextKey("history_many", 0, "last", "lastago", "first", "firstago"),
				new TextKey("history_once", 0, "last", "lastago"),
				new TextKey("history_you", 0),
				new TextKey("history_today", 0),
				new TextKey("history_yesterday", 0),
				new TextKey("history_days_ago", 1),
				new TextKey("import_done", 2),
				new TextKey("server_only_idle", 0)
			};
			foreach (var siteKind in SiteKinds)
			{
				string item = siteKind.Stem;
				list.Add(new TextKey(item + "_inside", 1));
				list.Add(new TextKey(item + "_entrance", 1));
				list.Add(new TextKey(item + "_due", 0));
			}
			foreach (var biomeKind in BiomeKinds)
			{
				string item2 = biomeKind.Key;
				list.Add(new TextKey(item2, 1));
			}
			foreach (GuardResult value in Enum.GetValues(typeof(GuardResult)))
			{
				if (value != GuardResult.Clear)
				{
					list.Add(new TextKey(Guard(value), 0));
				}
			}
			return list.ToArray();
		});

		public static IReadOnlyList<TextKey> All => all.Value;

		public static string ToCatalog(string key, string text)
		{
			if (!IsHistoryTemplate(key))
			{
				return text;
			}
			return text.Replace("{", "{{").Replace("}", "}}");
		}

		public static string FromCatalog(string key, string text)
		{
			if (!IsHistoryTemplate(key))
			{
				return text;
			}
			return string.Format(CultureInfo.InvariantCulture, text);
		}

		private static bool IsHistoryTemplate(string key)
		{
			if (!(key == "history_many"))
			{
				return key == "history_once";
			}
			return true;
		}

		public static string Guard(GuardResult guard)
		{
			return "guard_" + guard.ToString().ToLowerInvariant();
		}
	}
	public enum SiteNotice
	{
		Inside,
		Entrance,
		Due
	}
	public static class NoticeText
	{
		public static (string Key, int Count) Duration(ClockKind clock, int units)
		{
			if (clock == ClockKind.RealHours)
			{
				if (units != 1)
				{
					return (Key: "hours_many", Count: units);
				}
				return (Key: "hours_one", Count: 1);
			}
			if (units != 1)
			{
				return (Key: "days_many", Count: units);
			}
			return (Key: "days_one", Count: 1);
		}

		public static string Site(DelveKind kind, SiteNotice notice)
		{
			return ((from s in DelveTextKeys.SiteKinds
				where s.Kind == kind
				select s.Stem).FirstOrDefault() ?? throw new ArgumentException(kind.ToString() + " has no site notices.", "kind")) + "_" + notice.ToString().ToLowerInvariant();
		}

		public static string Biome(DelveKind kind)
		{
			return (from b in DelveTextKeys.BiomeKinds
				where b.Kind == kind
				select b.Key).FirstOrDefault() ?? throw new ArgumentException(kind.ToString() + " has no biome notice.", "kind");
		}
	}
	public sealed class NoticeCooldown
	{
		private readonly Dictionary<(long, string), (bool Inside, double LastTold)> state = new Dictionary<(long, string), (bool, double)>();

		public bool Enter(long player, string biome, bool inside, double nowMinutes, double cooldownMinutes)
		{
			(long, string) key = (player, biome ?? "");
			state.TryGetValue(key, out (bool, double) value);
			bool flag = state.ContainsKey(key);
			bool flag2 = inside && (!flag || !value.Item1) && (!flag || double.IsNegativeInfinity(value.Item2) || nowMinutes - value.Item2 >= cooldownMinutes);
			state[key] = (inside, flag2 ? nowMinutes : (flag ? value.Item2 : double.NegativeInfinity));
			return flag2;
		}

		public void Forget(long player)
		{
			foreach (var item in state.Keys.Where<(long, string)>(((long, string) k) => k.Item1 == player).ToList())
			{
				state.Remove(item);
			}
		}
	}
}
namespace ExtraPotions.Delve.Integration
{
	public enum HookKind
	{
		Method,
		Field
	}
	public enum HookStatus
	{
		Wired,
		Pending
	}
	public sealed class HookTarget
	{
		public string Module { get; }

		public string Type { get; }

		public string Member { get; }

		public HookKind Kind { get; }

		public string Signature { get; }

		public HookStatus Status { get; }

		public string Purpose { get; }

		internal HookTarget(string module, string type, string member, HookKind kind, string signature, HookStatus status, string purpose)
		{
			Module = module;
			Type = type;
			Member = member;
			Kind = kind;
			Signature = signature;
			Status = status;
			Purpose = purpose;
		}

		public override string ToString()
		{
			return Type + "." + Member + ((Kind == HookKind.Method) ? ("(" + Signature + ")") : (" : " + Signature));
		}
	}
	public static class HookTargets
	{
		public static IReadOnlyList<HookTarget> All { get; } = Array.AsReadOnly(new HookTarget[58]
		{
			M("Rooms", "DungeonGenerator", "GenerateRooms", "ZoneSystem/SpawnMode", HookStatus.Wired, "prefix sets min and max rooms, postfix restores them (A1)"),
			F("Rooms", "DungeonGenerator", "m_minRooms", "Int32", HookStatus.Wired, "the generator's own min rooms"),
			F("Rooms", "DungeonGenerator", "m_maxRooms", "Int32", HookStatus.Wired, "the generator's own max rooms"),
			F("Rooms", "DungeonGenerator", "m_algorithm", "DungeonGenerator/Algorithm", HookStatus.Wired, "only the Dungeon algorithm is sized"),
			M("FullReset", "DungeonGenerator", "Generate", "ZoneSystem/SpawnMode", HookStatus.Wired, "generate a wiped interior again in ghost mode (DV09)"),
			F("FullReset", "DungeonGenerator", "m_zoneSize", "Vector3", HookStatus.Wired, "the interior volume (DV09)"),
			M("FullReset", "ZNetView", "StartGhostInit", "", HookStatus.Wired, "ghost spawning as ZoneSystem does (DV09)"),
			M("FullReset", "ZNetView", "FinishGhostInit", "", HookStatus.Wired, "ghost spawning as ZoneSystem does (DV09)"),
			M("FullReset", "ZoneSystem", "GetZonePos", "Vector2s", HookStatus.Wired, "the interior's zone center (DV09)"),
			M("Surface", "ZoneSystem", "PlaceVegetation", "Vector2s,Vector3,Transform,Heightmap,List`1<ZoneSystem/ClearArea>,ZoneSystem/SpawnMode,List`1<GameObject>", HookStatus.Wired, "replay a generated zone's vegetation in ghost mode (parity 26, 27)"),
			M("Surface", "ZoneSystem", "IsZoneGenerated", "Vector2s", HookStatus.Wired, "only generated zones are reset (parity 26, 27)"),
			F("Surface", "ZoneSystem", "m_zones", "Dictionary`2<Vector2s,ZoneSystem/ZoneData>", HookStatus.Wired, "a loaded zone's own terrain (parity 26, 27)"),
			F("Surface", "ZoneSystem", "m_zonePrefab", "GameObject", HookStatus.Wired, "terrain for a zone no one has loaded on the server (parity 26, 27)"),
			F("Surface", "ZoneSystem", "m_locationInstances", "Dictionary`2<Vector2s,ZoneSystem/LocationInstance>", HookStatus.Wired, "location clear areas and exteriors (parity 26, 27)"),
			M("Surface", "HeightmapBuilder", "IsTerrainReady", "Vector3,Int32,Single,Boolean,WorldGenerator", HookStatus.Wired, "wait for a zone's terrain (parity 26, 27)"),
			F("Surface", "ZNetScene", "m_instances", "Dictionary`2<ZDO,ZNetView>", HookStatus.Wired, "loaded objects stand aside during the replay (parity 26, 27)"),
			F("Surface", "TreeBase", "m_stubPrefab", "GameObject", HookStatus.Wired, "clear a stump where a tree returns (parity 26, 27)"),
			F("Surface", "Destructible", "m_spawnWhenDestroyed", "GameObject", HookStatus.Wired, "a partly mined rock is the same rock (parity 26, 27)"),
			M("Commands", "ZNet", "RPC_Kick", "ZRpc,String", HookStatus.Wired, "kick fallback: delve-* words from a remote admin (DV11)"),
			M("Commands", "ZNet", "Kick", "String", HookStatus.Wired, "kick fallback: the host's or single player's own kick (DV11)"),
			M("Commands", "ZNet", "RemotePrint", "ZRpc,String", HookStatus.Wired, "reply in the admin's console (DV11)"),
			M("Engine", "EnvMan", "GetDay", "Double", HookStatus.Pending, "in-game day for clocks (DV03b)"),
			M("Engine", "ZNet", "GetTimeSeconds", "", HookStatus.Wired, "world time for fractional days and dawn (DV03b)"),
			F("Engine", "EnvMan", "m_dayLengthSec", "Int64", HookStatus.Wired, "day length for the world day (DV03b)"),
			M("Engine", "SaveSystem", "GetWorldsSaveRootPath", "FileHelpers/FileSource", HookStatus.Wired, "sidecar folder worlds_local (DV03b)"),
			M("Engine", "ZDOMan", "FindSectorObjects", "Vector2s,SimulationDistance,List`1<ZDO>,List`1<ZDO>", HookStatus.Wired, "objects near a site for clearance and bases (DV03b)"),
			F("Engine", "PrivateArea", "m_radius", "Single", HookStatus.Wired, "ward radius for the base guard (B6)"),
			F("Engine", "EffectArea", "m_type", "EffectArea/Type", HookStatus.Wired, "player base areas for the base guard (B6)"),
			F("Engine", "ZDOVars", "s_enabled", "Int32", HookStatus.Wired, "a disabled ward does not guard"),
			M("Engine", "ZoneSystem", "GetZone", "Vector3", HookStatus.Wired, "visit zones and nearby objects (DV06b)"),
			M("Engine", "ZNetScene", "InActiveArea", "Vector3,Vector3", HookStatus.Wired, "held rule (DV03b)"),
			M("Engine", "ZDOMan", "DestroyZDO", "ZDO", HookStatus.Wired, "remove a damaged object (DV06b)"),
			M("Engine", "ZDOMan", "CreateNewZDO", "Vector3,Int32", HookStatus.Wired, "create a restored object (DV06b)"),
			M("Chests", "ZDO", "Deserialize", "ZPackage", HookStatus.Wired, "openings and first sight (DV05b, DV06b)"),
			M("Chests", "Container", "SetInUse", "Boolean", HookStatus.Wired, "the host's own chest opening and closing (R-Q4)"),
			M("Chests", "Container", "Save", "", HookStatus.Wired, "the host's own chest emptying (R-Q4)"),
			F("Chests", "Container", "m_defaultItems", "DropTable", HookStatus.Wired, "a loot chest has a loot table (DV05b)"),
			F("Chests", "Container", "m_width", "Int32", HookStatus.Wired, "refill inventory size"),
			F("Chests", "Container", "m_height", "Int32", HookStatus.Wired, "refill inventory size"),
			M("Chests", "DropTable", "GetDropListItems", "", HookStatus.Wired, "roll the chest's own loot table"),
			M("Chests", "Inventory", "Save", "ZPackage", HookStatus.Wired, "write the fresh roll as the game does"),
			F("Chests", "ZDOVars", "s_items", "Int32", HookStatus.Wired, "chest inventory"),
			F("Chests", "ZDOVars", "s_inUse", "Int32", HookStatus.Wired, "chest open"),
			F("Chests", "ZDOVars", "s_creator", "Int32", HookStatus.Wired, "player-built objects"),
			F("Resources", "ZDOVars", "s_picked", "Int32", HookStatus.Wired, "unpick black cores and Morkhalla eyes"),
			F("Resources", "ZDOVars", "s_pickedTime", "Int32", HookStatus.Wired, "clear the picked time with the mark"),
			F("Resources", "ZDOVars", "s_roomData", "Int32", HookStatus.Wired, "the Queen's room from the generator's saved rooms (DV08)"),
			F("Resources", "ZDOVars", "s_state", "Int32", HookStatus.Wired, "close the citadel's sealed door (DV08)"),
			F("Resources", "ZDOVars", "s_location", "Int32", HookStatus.Wired, "find the Deep North boss room by its location proxy (Kall's return)"),
			F("Resources", "ZDOVars", "s_dead", "Int32", HookStatus.Wired, "a flametal spire that is leaving"),
			M("Resources", "WorldGenerator", "GetBiome", "Vector3", HookStatus.Wired, "biome entry notices (DV07)"),
			F("Respawn", "CreatureSpawner", "m_respawnTimeMinuts", "Single", HookStatus.Wired, "arm a one-shot spawner (DV15b)"),
			M("Respawn", "CreatureSpawner", "HasSpawned", "", HookStatus.Wired, "only spawners that spawned before"),
			M("Respawn", "CreatureSpawner", "Awake", "", HookStatus.Wired, "arm on load (Elite Creatures Reborn hook)"),
			M("Respawn", "CreatureSpawner", "Spawn", "", HookStatus.Wired, "arm after the first spawn"),
			M("Respawn", "ZDO", "GetConnection", "", HookStatus.Wired, "spawned state and the creature it points to (server reset)"),
			F("Respawn", "ZDOVars", "s_aliveTime", "Int32", HookStatus.Wired, "last time the spawner's creature lived (server reset)"),
			F("Respawn", "ZDOVars", "s_spawnTime", "Int32", HookStatus.Pending, "spawned state (server reset)")
		});

		public static IEnumerable<HookTarget> Wired => All.Where((HookTarget t) => t.Status == HookStatus.Wired);

		private static HookTarget M(string module, string type, string member, string parameters, HookStatus status, string purpose)
		{
			return new HookTarget(module, type, member, HookKind.Method, parameters, status, purpose);
		}

		private static HookTarget F(string module, string type, string member, string fieldType, HookStatus status, string purpose)
		{
			return new HookTarget(module, type, member, HookKind.Field, fieldType, status, purpose);
		}
	}
	public enum DelveModule
	{
		Rooms,
		FullReset,
		Chests,
		Resources,
		Respawn
	}
	public sealed class SourceInfo
	{
		public string Guid { get; }

		public string Name { get; }

		public IReadOnlyList<DelveModule> Modules { get; }

		internal SourceInfo(string guid, string name, params DelveModule[] modules)
		{
			Guid = guid;
			Name = name;
			Modules = Array.AsReadOnly(modules);
		}
	}
	public sealed class SourceSwitches
	{
		public static SourceSwitches Unknown { get; } = new SourceSwitches(vatDungeons: false, ecrRespawn: false, ecrLoot: false);

		public bool AdminToolDungeonResets { get; }

		public bool CreatureRespawn { get; }

		public bool DungeonLoot { get; }

		private SourceSwitches(bool vatDungeons, bool ecrRespawn, bool ecrLoot)
		{
			AdminToolDungeonResets = vatDungeons;
			CreatureRespawn = ecrRespawn;
			DungeonLoot = ecrLoot;
		}

		public static SourceSwitches Read(string? adminToolConfig, string? creatureRules)
		{
			bool vatDungeons = false;
			if (adminToolConfig != null)
			{
				vatDungeons = CfgFile.Parse(adminToolConfig).Bool("Automatic resets", "Reset dungeons automatically") == true;
			}
			IReadOnlyDictionary<string, string> block = SourceImport.RespawningBlock(creatureRules);
			bool flag = Flag(block, "camps");
			bool flag2 = Flag(block, "dungeons");
			bool ecrLoot = Flag(block, "dungeon loot");
			return new SourceSwitches(vatDungeons, flag || flag2, ecrLoot);
		}

		private static bool Flag(IReadOnlyDictionary<string, string> block, string key)
		{
			string value;
			bool result = default(bool);
			return block.TryGetValue(key, out value) && bool.TryParse(value, out result) && result;
		}
	}
	public sealed class StepAsideNotice
	{
		public DelveModule Module { get; }

		public string SourceGuid { get; }

		public string SourceName { get; }

		public string Key => ModuleStepAside.KeyOf(Module);

		internal StepAsideNotice(DelveModule module, SourceInfo source)
		{
			Module = module;
			SourceGuid = source.Guid;
			SourceName = source.Name;
		}
	}
	public sealed class ModuleStepAsideDecision
	{
		public IReadOnlyList<StepAsideNotice> Notices { get; }

		public IReadOnlyList<DelveModule> Modules => (from n in Notices
			select n.Module into m
			orderby m
			select m).ToArray();

		public bool Any => Notices.Count > 0;

		internal ModuleStepAsideDecision(IReadOnlyList<StepAsideNotice> notices)
		{
			Notices = notices;
		}

		public bool SteppedAside(DelveModule module)
		{
			return Notices.Any((StepAsideNotice n) => n.Module == module);
		}
	}
	public static class ModuleStepAside
	{
		public static readonly SourceInfo MaxDungeonRooms = new SourceInfo("digitalroot.mods.maxdungeonrooms", "Max_Dungeon_Rooms", default(DelveModule));

		public static readonly SourceInfo MoreDungeonResets = new SourceInfo("com.loathe.MoreDungeonResets", "MoreDungeonResets", DelveModule.FullReset);

		public static readonly SourceInfo RestockRegen = new SourceInfo("liekos47.restockregen", "RestockRegen", DelveModule.Chests, DelveModule.Resources);

		public static readonly SourceInfo ValheimAdminTool = new SourceInfo("com.icecub.valheimadmintool", "Valheim_Admin_Tool", DelveModule.FullReset);

		public static readonly SourceInfo EliteCreaturesReborn = new SourceInfo("gglasgow.elitecreaturesreborn", "Elite Creatures Reborn", DelveModule.Chests, DelveModule.Respawn);

		public static IReadOnlyList<SourceInfo> Sources { get; } = Array.AsReadOnly(new SourceInfo[5] { MaxDungeonRooms, MoreDungeonResets, RestockRegen, ValheimAdminTool, EliteCreaturesReborn });

		public static string KeyOf(DelveModule module)
		{
			return "step_aside_" + module.ToString().ToLowerInvariant();
		}

		public static DelveModule ModuleOf(DelveKind kind)
		{
			switch (kind)
			{
			case DelveKind.FullReset:
				return DelveModule.FullReset;
			case DelveKind.Chests:
				return DelveModule.Chests;
			case DelveKind.CampSpawners:
			case DelveKind.DungeonSpawners:
				return DelveModule.Respawn;
			default:
				return DelveModule.Resources;
			}
		}

		public static ModuleStepAsideDecision Decide(IEnumerable<string> installed, SourceSwitches switches)
		{
			if (installed == null)
			{
				throw new ArgumentNullException("installed");
			}
			if (switches == null)
			{
				throw new ArgumentNullException("switches");
			}
			HashSet<string> hashSet = new HashSet<string>(installed, StringComparer.Ordinal);
			List<StepAsideNotice> list = new List<StepAsideNotice>();
			foreach (SourceInfo source in Sources)
			{
				if (!hashSet.Contains(source.Guid))
				{
					continue;
				}
				foreach (DelveModule module in source.Modules)
				{
					if (Acts(source, module, switches) && !list.Any((StepAsideNotice n) => n.Module == module))
					{
						list.Add(new StepAsideNotice(module, source));
					}
				}
			}
			return new ModuleStepAsideDecision(list);
		}

		private static bool Acts(SourceInfo source, DelveModule module, SourceSwitches switches)
		{
			if (source == ValheimAdminTool)
			{
				return switches.AdminToolDungeonResets;
			}
			if (source == EliteCreaturesReborn)
			{
				if (module != DelveModule.Respawn)
				{
					return switches.DungeonLoot;
				}
				return switches.CreatureRespawn;
			}
			return true;
		}
	}
}
namespace ExtraPotions.Delve.Engine
{
	public readonly struct Stamp
	{
		public double Day { get; }

		public DateTime Utc { get; }

		public bool HasDay { get; }

		public bool HasUtc { get; }

		private Stamp(double day, DateTime utc, bool hasDay, bool hasUtc)
		{
			Day = day;
			Utc = utc;
			HasDay = hasDay;
			HasUtc = hasUtc;
		}

		public static Stamp At(double day, DateTime time)
		{
			if (double.IsNaN(day) || double.IsInfinity(day))
			{
				throw new ArgumentException("Expected a finite world day.", "day");
			}
			if (time.Kind == DateTimeKind.Unspecified)
			{
				throw new ArgumentException("Expected a UTC or local time, not an unspecified one.", "time");
			}
			return new Stamp(day, time.ToUniversalTime(), hasDay: true, hasUtc: true);
		}

		public static Stamp DayOnly(double day)
		{
			if (double.IsNaN(day) || double.IsInfinity(day))
			{
				throw new ArgumentException("Expected a finite world day.", "day");
			}
			return new Stamp(day, default(DateTime), hasDay: true, hasUtc: false);
		}

		public static Stamp UtcOnly(DateTime time)
		{
			if (time.Kind == DateTimeKind.Unspecified)
			{
				throw new ArgumentException("Expected a UTC or local time, not an unspecified one.", "time");
			}
			return new Stamp(0.0, time.ToUniversalTime(), hasDay: false, hasUtc: true);
		}

		public Stamp CompletedWith(Stamp now)
		{
			return new Stamp(HasDay ? Day : now.Day, HasUtc ? Utc : now.Utc, HasDay || now.HasDay, HasUtc || now.HasUtc);
		}

		public override string ToString()
		{
			return (HasDay ? ("day " + Day.ToString("0.###", CultureInfo.InvariantCulture)) : "day ?") + " / " + (HasUtc ? Utc.ToString("u", CultureInfo.InvariantCulture) : "utc ?");
		}
	}
	public static class ClockRules
	{
		public const double MinDelay = 0.25;

		public const double MaxDays = 3650.0;

		public const double MaxHours = 87600.0;

		public static double Clamp(ClockKind clock, double delay, double fallback = 30.0)
		{
			if (double.IsNaN(delay) || double.IsInfinity(delay))
			{
				delay = fallback;
			}
			return Math.Min((clock == ClockKind.RealHours) ? 87600.0 : 3650.0, Math.Max(0.25, delay));
		}

		public static double Elapsed(ClockKind clock, Stamp since, Stamp now)
		{
			if (clock == ClockKind.RealHours)
			{
				if (!since.HasUtc || !now.HasUtc)
				{
					return 0.0;
				}
				return Math.Max(0.0, (now.Utc - since.Utc).TotalHours);
			}
			if (!since.HasDay || !now.HasDay)
			{
				return 0.0;
			}
			return Math.Max(0.0, now.Day - since.Day);
		}

		public static bool Due(ClockKind clock, double delay, Stamp since, Stamp now)
		{
			return Elapsed(clock, since, now) >= Clamp(clock, delay) - 1E-09;
		}

		public static double Remaining(ClockKind clock, double delay, Stamp since, Stamp now)
		{
			return Math.Max(0.0, Clamp(clock, delay) - Elapsed(clock, since, now));
		}

		public static (double? Remaining, bool Due) Inspect(ClockKind clock, double delay, Stamp? since, Stamp now, bool requested)
		{
			bool flag = since.HasValue && ((clock != ClockKind.RealHours) ? (since.Value.HasDay && now.HasDay) : (since.Value.HasUtc && now.HasUtc));
			return (Remaining: flag ? new double?(Remaining(clock, delay, since.Value, now)) : ((double?)null), Due: requested || (flag && Due(clock, delay, since.Value, now)));
		}

		public static int WholeUnitsLeft(double remaining)
		{
			if (!(remaining <= 1E-09))
			{
				return (int)Math.Ceiling(remaining - 1E-09);
			}
			return 0;
		}
	}
	public static class DelveKeys
	{
		public const string ChestSinceDay = "delve.chest.since_day";

		public const string ChestSinceUtc = "delve.chest.since_utc";

		public const string ChestFirstBy = "delve.chest.first_by";

		public const string ChestFirstDay = "delve.chest.first_day";

		public const string ChestLastBy = "delve.chest.last_by";

		public const string ChestLastDay = "delve.chest.last_day";

		public const string FullResetRetry = "delve.fullreset.retry";

		public static IReadOnlyList<string> Fixed { get; } = Array.AsReadOnly(new string[7] { "delve.chest.since_day", "delve.chest.since_utc", "delve.chest.first_by", "delve.chest.first_day", "delve.chest.last_by", "delve.chest.last_day", "delve.fullreset.retry" });

		private static string Stem(DelveKind kind)
		{
			return "delve." + kind.ToString().ToLowerInvariant();
		}

		public static string Spots(DelveKind kind)
		{
			return Stem(kind) + ".spots";
		}

		public static string VisitDay(DelveKind kind)
		{
			return Stem(kind) + ".visit_day";
		}

		public static string VisitUtc(DelveKind kind)
		{
			return Stem(kind) + ".visit_utc";
		}

		public static float EncodeDay(Stamp? stamp)
		{
			if (!stamp.HasValue || !stamp.Value.HasDay)
			{
				return 0f;
			}
			return (float)(stamp.Value.Day + 1.0);
		}

		public static long EncodeUtc(Stamp? stamp)
		{
			if (!stamp.HasValue || !stamp.Value.HasUtc)
			{
				return 0L;
			}
			return stamp.Value.Utc.Ticks;
		}

		public static Stamp? Decode(float dayPlusOne, long utcTicks)
		{
			bool flag = dayPlusOne > 0f && !float.IsNaN(dayPlusOne) && !float.IsInfinity(dayPlusOne);
			bool flag2 = utcTicks > 0 && utcTicks <= DateTime.MaxValue.Ticks;
			if (flag && flag2)
			{
				return Stamp.At((double)dayPlusOne - 1.0, new DateTime(utcTicks, DateTimeKind.Utc));
			}
			if (flag)
			{
				return Stamp.DayOnly((double)dayPlusOne - 1.0);
			}
			if (flag2)
			{
				return Stamp.UtcOnly(new DateTime(utcTicks, DateTimeKind.Utc));
			}
			return null;
		}
	}
	public enum DungeonMode
	{
		Off,
		Resources,
		Full
	}
	public static class DungeonModes
	{
		public static readonly IReadOnlyDictionary<string, DungeonMode> Defaults = new Dictionary<string, DungeonMode>(StringComparer.Ordinal)
		{
			["DG_SunkenCrypt"] = DungeonMode.Resources,
			["DG_Cave"] = DungeonMode.Resources,
			["DG_DvergrTown"] = DungeonMode.Resources,
			["DG_MorkHalla"] = DungeonMode.Resources,
			["DG_Hole"] = DungeonMode.Resources,
			["DG_DvergrBoss"] = DungeonMode.Resources
		};

		public static DungeonMode Default(string generator)
		{
			if (generator == null || !Defaults.TryGetValue(generator, out var value))
			{
				return DungeonMode.Off;
			}
			return value;
		}

		public static bool Allows(DungeonMode mode, DelveKind kind)
		{
			switch (kind)
			{
			case DelveKind.FullReset:
				return mode == DungeonMode.Full;
			case DelveKind.MudPiles:
			case DelveKind.FrostCaveCrystals:
			case DelveKind.BlackCores:
			case DelveKind.Morkhalla:
			case DelveKind.Hole:
			case DelveKind.Queen:
				return mode == DungeonMode.Resources;
			case DelveKind.Chests:
				return mode != DungeonMode.Full;
			default:
				return true;
			}
		}
	}
	public sealed class DungeonSiteReport
	{
		public string Id { get; }

		public DelveKind Kind { get; }

		public string Generator { get; }

		public Vec3 Entrance { get; }

		public ClockKind Clock { get; }

		public double? Remaining { get; }

		public bool Requested { get; }

		public bool EvaluationPending { get; }

		public bool Due { get; }

		public bool DryRun { get; }

		public DungeonSiteReport(string id, DelveKind kind, string generator, Vec3 entrance, ClockKind clock, double delay, Stamp? lastVisit, Stamp now, bool requested, bool dryRun, bool evaluationPending = false)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				throw new ArgumentException("Expected a site identity.", "id");
			}
			if (string.IsNullOrWhiteSpace(generator))
			{
				throw new ArgumentException("Expected a generator name.", "generator");
			}
			if (!Finite(entrance.X) || !Finite(entrance.Y) || !Finite(entrance.Z))
			{
				throw new ArgumentException("Expected a finite entrance position.", "entrance");
			}
			Id = id;
			Kind = kind;
			Generator = generator;
			Entrance = entrance;
			Clock = clock;
			Requested = requested;
			DryRun = dryRun;
			EvaluationPending = evaluationPending;
			(Remaining, Due) = ClockRules.Inspect(clock, delay, lastVisit, now, requested);
		}

		private static bool Finite(float n)
		{
			if (!float.IsNaN(n))
			{
				return !float.IsInfinity(n);
			}
			return false;
		}
	}
	public sealed class KindReport
	{
		public int Tracked { get; }

		public int Waiting { get; }

		public int Deferred { get; }

		public int Acted { get; }

		public IReadOnlyDictionary<GuardResult, int> Blocked { get; }

		public bool Active { get; }

		public bool DryRun { get; }

		public string? Note { get; }

		public KindReport(int tracked, int waiting, int deferred, int acted, IReadOnlyDictionary<GuardResult, int>? blocked, bool active, bool dryRun, string? note = null)
		{
			Tracked = tracked;
			Waiting = waiting;
			Deferred = deferred;
			Acted = acted;
			Blocked = blocked ?? new Dictionary<GuardResult, int>();
			Active = active;
			DryRun = dryRun;
			Note = note;
		}
	}
	public sealed class EngineStatus
	{
		private readonly Dictionary<DelveKind, KindReport> kinds = new Dictionary<DelveKind, KindReport>();

		private readonly LinkedList<string> actions = new LinkedList<string>();

		private int capacity;

		public IEnumerable<string> LastActions => actions;

		public EngineStatus(int lines)
		{
			Resize(lines);
		}

		public void Resize(int lines)
		{
			capacity = Math.Max(1, lines);
			while (actions.Count > capacity)
			{
				actions.RemoveLast();
			}
		}

		public void Record(DelveKind kind, string what, bool dryRun, Stamp when)
		{
			actions.AddFirst(Day(when) + " " + kind.ToString() + ": " + (dryRun ? "dry run: would have " : "") + what);
			while (actions.Count > capacity)
			{
				actions.RemoveLast();
			}
		}

		public void Set(DelveKind kind, KindReport report)
		{
			kinds[kind] = report ?? throw new ArgumentNullException("report");
		}

		public KindReport? Get(DelveKind kind)
		{
			if (!kinds.TryGetValue(kind, out KindReport value))
			{
				return null;
			}
			return value;
		}

		public IEnumerable<string> Lines(Stamp now, bool dryRunAll, Func<GuardResult, string>? reason = null)
		{
			yield return "Delve status, " + Day(now) + (dryRunAll ? " (DRY RUN for every kind)" : "");
			foreach (DelveKind value2 in Enum.GetValues(typeof(DelveKind)))
			{
				if (!kinds.TryGetValue(value2, out KindReport value))
				{
					continue;
				}
				if (!value.Active)
				{
					yield return value2.ToString() + ": off" + ((value.Note != null) ? (" (" + value.Note + ")") : "");
					continue;
				}
				string text = string.Join(", ", from b in value.Blocked
					where b.Value > 0
					select ((reason != null) ? reason(b.Key) : b.Key.ToString()) + " " + b.Value);
				yield return value2.ToString() + ": " + value.Tracked + " tracked, " + value.Waiting + " waiting, " + value.Deferred + " deferred, " + value.Acted + " acted" + ((text.Length > 0) ? (", blocked: " + text) : "") + (value.DryRun ? " (dry run)" : "") + ((value.Note != null) ? (" (" + value.Note + ")") : "");
			}
			foreach (string action in actions)
			{
				yield return "  " + action;
			}
		}

		private static string Day(Stamp s)
		{
			if (!s.HasDay)
			{
				return "day ?";
			}
			return "day " + s.Day.ToString("0.##", CultureInfo.InvariantCulture);
		}
	}
	public readonly struct Vec3 : IEquatable<Vec3>
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

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

		public static float Flat(Vec3 a, Vec3 b)
		{
			float num = a.X - b.X;
			float num2 = a.Z - b.Z;
			return (float)Math.Sqrt(num * num + num2 * num2);
		}

		public static float SqrDistance(Vec3 a, Vec3 b)
		{
			float num = a.X - b.X;
			float num2 = a.Y - b.Y;
			float num3 = a.Z - b.Z;
			return num * num + num2 * num2 + num3 * num3;
		}

		public bool Equals(Vec3 other)
		{
			if (X.Equals(other.X) && Y.Equals(other.Y))
			{
				return Z.Equals(other.Z);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((X.GetHashCode() * 397) ^ Y.GetHashCode()) * 397) ^ Z.GetHashCode();
		}

		public override string ToString()
		{
			return "(" + X.ToString("0.##", CultureInfo.InvariantCulture) + ", " + Y.ToString("0.##", CultureInfo.InvariantCulture) + ", " + Z.ToString("0.##", CultureInfo.InvariantCulture) + ")";
		}
	}
	public readonly struct Box
	{
		public Vec3 Min { get; }

		public Vec3 Max { get; }

		public Box(Vec3 min, Vec3 max)
		{
			if (min.X > max.X || min.Y > max.Y || min.Z > max.Z)
			{
				throw new ArgumentException("Expected min below max on every axis.");
			}
			Min = min;
			Max = max;
		}

		public bool Contains(Vec3 p)
		{
			if (p.X >= Min.X && p.X <= Max.X && p.Y >= Min.Y && p.Y <= Max.Y && p.Z >= Min.Z)
			{
				return p.Z <= Max.Z;
			}
			return false;
		}
	}
	public readonly struct Area
	{
		public Vec3 Center { get; }

		public float Radius { get; }

		public Area(Vec3 center, float radius)
		{
			if (!(radius >= 0f) || float.IsInfinity(radius))
			{
				throw new ArgumentException("Expected a finite radius of 0 or more.", "radius");
			}
			Center = center;
			Radius = radius;
		}

		public bool Contains(Vec3 p)
		{
			return Vec3.Flat(Center, p) <= Radius;
		}
	}
	public enum GuardResult
	{
		Clear,
		PlayerNear,
		Held,
		Built,
		PlayerBase
	}
	public sealed class GuardInput
	{
		public Vec3 Center { get; }

		public float PlayerRadius { get; }

		public Box? Interior { get; set; }

		public IReadOnlyList<Vec3> Players { get; set; } = Array.Empty<Vec3>();

		public bool HeldByPlayer { get; set; }

		public float Clearance { get; set; }

		public IReadOnlyList<Vec3> Built { get; set; } = Array.Empty<Vec3>();

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

		public IReadOnlyList<Area> Bases { get; set; } = Array.Empty<Area>();

		public GuardInput(Vec3 center, float playerRadius)
		{
			if (!(playerRadius >= 0f) || float.IsInfinity(playerRadius))
			{
				throw new ArgumentException("Expected a finite radius of 0 or more.", "playerRadius");
			}
			Center = center;
			PlayerRadius = playerRadius;
		}
	}
	public static class Guards
	{
		public static GuardResult Evaluate(GuardInput input)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			foreach (Vec3 player in input.Players)
			{
				if (Vec3.Flat(player, input.Center) < input.PlayerRadius || (input.Interior.HasValue && input.Interior.Value.Contains(player)))
				{
					return GuardResult.PlayerNear;
				}
			}
			if (input.HeldByPlayer)
			{
				return GuardResult.Held;
			}
			if (WorldRules.BuiltNear(input.Center, input.Clearance, input.Built))
			{
				return GuardResult.Built;
			}
			if (input.BaseGuard)
			{
				foreach (Area basis in input.Bases)
				{
					if (basis.Contains(input.Center))
					{
						return GuardResult.PlayerBase;
					}
				}
			}
			return GuardResult.Clear;
		}
	}
	public enum ClockKind
	{
		InGameDays,
		RealHours
	}
	public enum DelveKind
	{
		FullReset,
		Chests,
		MudPiles,
		FrostCaveCrystals,
		BlackCores,
		Morkhalla,
		Hole,
		AncientArmor,
		Obsidian,
		Flametal,
		Ice,
		Queen,
		CampSpawners,
		DungeonSpawners,
		Kall
	}
	public sealed class Candidate
	{
		public string SiteId { get; }

		public DelveKind Kind { get; }

		public Stamp Since { get; }

		public GuardResult Guard { get; }

		public bool RegenerateNow { get; }

		public Candidate(string siteId, DelveKind kind, Stamp since, GuardResult guard, bool regenerateNow = false)
		{
			if (string.IsNullOrWhiteSpace(siteId))
			{
				throw new ArgumentException("Expected a site id.", "siteId");
			}
			SiteId = siteId;
			Kind = kind;
			Since = since;
			Guard = guard;
			RegenerateNow = regenerateNow;
		}
	}
	public sealed class SchedulerOptions
	{
		public int MaxActions { get; }

		public bool DryRunAll { get; }

		public Func<DelveKind, (ClockKind Clock, double Delay)> ClockOf { get; }

		public Func<DelveKind, bool> DryRunOf { get; }

		public SchedulerOptions(int maxActions, bool dryRunAll, Func<DelveKind, (ClockKind Clock, double Delay)> clockOf, Func<DelveKind, bool> dryRunOf)
		{
			if (maxActions < 1)
			{
				throw new ArgumentOutOfRangeException("maxActions", "Expected at least one action per check.");
			}
			MaxActions = maxActions;
			DryRunAll = dryRunAll;
			ClockOf = clockOf ?? throw new ArgumentNullException("clockOf");
			DryRunOf = dryRunOf ?? throw new ArgumentNullException("dryRunOf");
		}
	}
	public sealed class PlannedAction
	{
		public Candidate Site { get; }

		public string SiteId => Site.SiteId;

		public DelveKind Kind => Site.Kind;

		public bool DryRun { get; }

		public double Overdue { get; }

		internal PlannedAction(Candidate site, bool dryRun, double overdue)
		{
			Site = site;
			DryRun = dryRun;
			Overdue = overdue;
		}
	}
	public sealed class SchedulePlan
	{
		public IReadOnlyList<PlannedAction> Actions { get; }

		public int Waiting { get; }

		public int Deferred { get; }

		public IReadOnlyDictionary<GuardResult, int> Blocked { get; }

		internal SchedulePlan(IReadOnlyList<PlannedAction> actions, int waiting, int deferred, IReadOnlyDictionary<GuardResult, int> blocked)
		{
			Actions = actions;
			Waiting = waiting;
			Deferred = deferred;
			Blocked = blocked;
		}
	}
	public static class Scheduler
	{
		public static SchedulePlan Plan(IEnumerable<Candidate> sites, Stamp now, SchedulerOptions options)
		{
			if (sites == null)
			{
				throw new ArgumentNullException("sites");
			}
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			Dictionary<GuardResult, int> dictionary = (from GuardResult g in Enum.GetValues(typeof(GuardResult))
				where g != GuardResult.Clear
				select g).ToDictionary((GuardResult g) => g, (GuardResult g) => 0);
			List<PlannedAction> list = new List<PlannedAction>();
			int num = 0;
			foreach (Candidate site in sites)
			{
				(ClockKind, double) tuple = options.ClockOf(site.Kind);
				ClockKind item = tuple.Item1;
				double item2 = tuple.Item2;
				Stamp since = site.Since.CompletedWith(now);
				double overdue;
				if (site.RegenerateNow)
				{
					overdue = double.MaxValue;
				}
				else
				{
					if (!ClockRules.Due(item, item2, since, now))
					{
						num++;
						continue;
					}
					overdue = ClockRules.Elapsed(item, since, now) - ClockRules.Clamp(item, item2);
				}
				if (site.Guard != GuardResult.Clear)
				{
					dictionary[site.Guard]++;
				}
				else
				{
					list.Add(new PlannedAction(site, options.DryRunAll || options.DryRunOf(site.Kind), overdue));
				}
			}
			List<PlannedAction> list2 = list.OrderByDescending((PlannedAction a) => a.Overdue).ThenBy<PlannedAction, string>((PlannedAction a) => a.SiteId, StringComparer.Ordinal).ToList();
			List<PlannedAction> list3 = list2.Take(options.MaxActions).ToList();
			return new SchedulePlan(list3, num, list2.Count - list3.Count, dictionary);
		}
	}
	public readonly struct ImportCount
	{
		public int Spots { get; }

		public int Visits { get; }

		public ImportCount(int spots, int visits)
		{
			Spots = spots;
			Visits = visits;
		}
	}
	public sealed class Sidecar
	{
		public const int Version = 1;

		private bool readOnly;

		private static readonly Lazy<HashSet<int>> drifting = new Lazy<HashSet<int>>(() => new HashSet<int>(KindCatalog.All.Where((KindInfo k) => k.Drifts).SelectMany((KindInfo k) => k.Whole).Select(StableHash.Of)));

		public List<RecordSpot> Spots { get; } = new List<RecordSpot>();

		public Dictionary<(int X, int Z), Stamp> Visits { get; } = new Dictionary<(int, int), Stamp>();

		public HashSet<DelveKind> RegenerateNow { get; } = new HashSet<DelveKind>();

		public bool ImportedRestockRegen { get; set; }

		public bool ReadOnly => readOnly;

		public string Write()
		{
			return MiniJson.Write(new Dictionary<string, object>
			{
				["version"] = 1,
				["importedRestockRegen"] = ImportedRestockRegen,
				["regenerateNow"] = ((IEnumerable<DelveKind>)RegenerateNow.OrderBy((DelveKind k) => k)).Select((Func<DelveKind, object>)((DelveKind k) => k.ToString())).ToList(),
				["visits"] = ((IEnumerable<KeyValuePair<(int, int), Stamp>>)(from v in Visits
					orderby v.Key.X, v.Key.Z
					select v)).Select((Func<KeyValuePair<(int, int), Stamp>, object>)((KeyValuePair<(int X, int Z), Stamp> v) => new List<object>
				{
					v.Key.X,
					v.Key.Z,
					StampValue(v.Value)
				})).ToList(),
				["spots"] = ((IEnumerable<RecordSpot>)Spots).Select((Func<RecordSpot, object>)((RecordSpot s) => new List<object>
				{
					s.Prefab,
					s.Position.X,
					s.Position.Y,
					s.Position.Z,
					s.Rotation.X,
					s.Rotation.Y,
					s.Rotation.Z
				})).ToList()
			});
		}

		public static Sidecar Parse(string? text, out List<string> errors)
		{
			errors = new List<string>();
			Sidecar sidecar = new Sidecar();
			if (string.IsNullOrWhiteSpace(text))
			{
				return sidecar;
			}
			try
			{
				if (!(MiniJson.Parse(text) is IDictionary<string, object> dictionary))
				{
					throw new FormatException("JSON root is not an object.");
				}
				object value;
				int num = ((dictionary.TryGetValue("version", out value) && value is double num2) ? ((int)num2) : 0);
				if (num != 1)
				{
					errors.Add("sidecar version " + num + " is not " + 1 + "; starting empty and leaving the file alone");
					return new Sidecar
					{
						readOnly = true
					};
				}
				bool flag = default(bool);
				int num3;
				if (dictionary.TryGetValue("importedRestockRegen", out var value2))
				{
					if (value2 is bool)
					{
						flag = (bool)value2;
						num3 = 1;
					}
					else
					{
						num3 = 0;
					}
				}
				else
				{
					num3 = 0;
				}
				sidecar.ImportedRestockRegen = (byte)((uint)num3 & (flag ? 1u : 0u)) != 0;
				foreach (object item in List(dictionary, "regenerateNow"))
				{
					if (item is string value3 && Enum.TryParse<DelveKind>(value3, out var result))
					{
						sidecar.RegenerateNow.Add(result);
					}
				}
				foreach (object item2 in List(dictionary, "visits"))
				{
					if (item2 is IList<object> { Count: 3 } list && list[0] is double num4 && list[1] is double num5)
					{
						Stamp? stamp = Read(list[2]);
						if (stamp.HasValue)
						{
							Stamp valueOrDefault = stamp.GetValueOrDefault();
							sidecar.Visits[((int)num4, (int)num5)] = valueOrDefault;
							continue;
						}
					}
					errors.Add("skipped a visit entry");
				}
				foreach (object item3 in List(dictionary, "spots"))
				{
					if (item3 is IList<object> { Count: 7 } list2 && list2.All((object n) => n is double))
					{
						double[] array = list2.Cast<double>().ToArray();
						sidecar.Spots.Add(new RecordSpot((int)array[0], new Vec3((float)array[1], (float)array[2], (float)array[3]), new Vec3((float)array[4], (float)array[5], (float)array[6])));
					}
					else
					{
						errors.Add("skipped a spot entry");
					}
				}
				return sidecar;
			}
			catch (FormatException ex)
			{
				errors.Add("sidecar unreadable (" + ex.Message + "); starting empty and leaving the file alone");
				return new Sidecar
				{
					readOnly = true
				};
			}
		}

		public ImportCount ImportRestockRegen(RecordFile restockRegen)
		{
			if (restockRegen == null)
			{
				throw new ArgumentNullException("restockRegen");
			}
			int num = 0;
			int num2 = 0;
			foreach (RecordSpot spot in restockRegen.Spots)
			{
				if (!Spots.Any((RecordSpot s) => Same(s, spot)))
				{
					Spots.Add(spot);
					num++;
				}
			}
			foreach (KeyValuePair<(int, int), int> visit in restockRegen.Visits)
			{
				if (!Visits.ContainsKey(visit.Key))
				{
					Visits[visit.Key] = Stamp.DayOnly(visit.Value);
					num2++;
				}
			}
			ImportedRestockRegen = true;
			return new ImportCount(num, num2);
		}

		private static bool Same(RecordSpot a, RecordSpot b)
		{
			if (a.Prefab != b.Prefab)
			{
				return false;
			}
			if (!drifting.Value.Contains(a.Prefab))
			{
				return Vec3.SqrDistance(a.Position, b.Position) < 0.04f;
			}
			return Vec3.Flat(a.Position, b.Position) < 6f;
		}

		private static IEnumerable<object?> List(IDictionary<string, object?> root, string key)
		{
			if (!root.TryGetValue(key, out object value) || !(value is IList<object> result))
			{
				return Enumerable.Empty<object>();
			}
			return result;
		}

		private static object StampValue(Stamp s)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			if (s.HasDay)
			{
				dictionary["day"] = s.Day;
			}
			if (s.HasUtc)
			{
				dictionary["utc"] = s.Utc.ToString("o", CultureInfo.InvariantCulture);
			}
			return dictionary;
		}

		private static Stamp? Read(object? value)
		{
			if (!(value is IDictionary<string, object> dictionary))
			{
				return null;
			}
			object value2;
			bool flag = dictionary.TryGetValue("day", out value2) && value2 is double;
			DateTime result = default(DateTime);
			object value3;
			bool flag2 = dictionary.TryGetValue("utc", out value3) && value3 is string s && DateTime.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out result) && result.Kind == DateTimeKind.Utc;
			if (flag && flag2)
			{
				return Stamp.At((double)value2, result);
			}
			if (flag)
			{
				return Stamp.DayOnly((double)value2);
			}
			if (flag2)
			{
				return Stamp.UtcOnly(result);
			}
			return null;
		}
	}
	public static class WorldClock
	{
		public const double DawnFraction = 0.15;

		public static Stamp Now(double worldSeconds, double dayLengthSeconds, DateTime utcNow)
		{
			Check(dayLengthSeconds);
			return Stamp.At(Math.Max(0.0, worldSeconds) / dayLengthSeconds, utcNow);
		}

		public static int DayIndex(double worldSeconds, double dayLengthSeconds)
		{
			Check(dayLengthSeconds);
			return (int)Math.Floor(Math.Max(0.0, worldSeconds) / dayLengthSeconds);
		}

		public static bool DawnBetween(double previousSeconds, double nowSeconds, double dayLengthSeconds)
		{
			Check(dayLengthSeconds);
			if (!(nowSeconds > previousSeconds))
			{
				return false;
			}
			double num = 0.15 * dayLengthSeconds;
			return Math.Floor((previousSeconds - num) / dayLengthSeconds + 1.0) * dayLengthSeconds + num <= nowSeconds;
		}

		public static bool ShouldSweep(ClockKind clock, bool dawn, bool regenerateNow)
		{
			return regenerateNow || clock == ClockKind.RealHours || dawn;
		}

		public static Stamp FromGameTicks(long ticks, double dayLengthSeconds)
		{
			Check(dayLengthSeconds);
			if (ticks <= 0)
			{
				return default(Stamp);
			}
			return Stamp.DayOnly((double)ticks / 10000000.0 / dayLengthSeconds);
		}

		private static void Check(double dayLengthSeconds)
		{
			if (!(dayLengthSeconds > 0.0) || double.IsInfinity(dayLengthSeconds))
			{
				throw new ArgumentException("Expected a positive day length.", "dayLengthSeconds");
			}
		}
	}
	public static class WorldRules
	{
		public const float ClearanceHeight = 30f;

		public static bool HeldByPlayer(bool hasOwner, bool ownerIsServer, bool ownerConnected, bool inOwnerActiveArea)
		{
			return hasOwner && !ownerIsServer && ownerConnected && inOwnerActiveArea;
		}

		public static bool BuiltNear(Vec3 spot, float clearance, IEnumerable<Vec3> playerBuilt)
		{
			if (clearance <= 0f || playerBuilt == null)
			{
				return false;
			}
			foreach (Vec3 item in playerBuilt)
			{
				if (Vec3.Flat(item, spot) < clearance && Math.Abs(item.Y - spot.Y) < 30f)
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace ExtraPotions.Delve.Data
{
	public sealed class DungeonsFile
	{
		public const string FileName = "Delve.Dungeons.yml";

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

		public IReadOnlyDictionary<string, DungeonMode> Modes { get; }

		public IReadOnlyList<string> Errors { get; }

		private DungeonsFile(IReadOnlyDictionary<string, DungeonMode> modes, IReadOnlyList<string> errors)
		{
			Modes = modes;
			Errors = errors;
		}

		public DungeonMode ModeOf(string generator)
		{
			if (generator == null || !Modes.TryGetValue(generator, out var value))
			{
				return DungeonModes.Default(generator);
			}
			return value;
		}

		public static DungeonsFile Parse(string? text)
		{
			List<string> list = new List<string>();
			Dictionary<string, DungeonMode> dictionary = new Dictionary<string, DungeonMode>(StringComparer.Ordinal);
			if (MiniYaml.Read(text, list).TryGetValue("modes", out IReadOnlyList<YamlEntry> value))
			{
				foreach (YamlEntry item in value)
				{
					if (item.Scalar != null && Enum.TryParse<DungeonMode>(item.Scalar, ignoreCase: true, out var result) && Enum.IsDefined(typeof(DungeonMode), result) && !int.TryParse(item.Scalar, out var result2))
					{
						dictionary[item.Name] = result;
						continue;
					}
					string[] obj = new string[5] { "line ", null, null, null, null };
					result2 = item.Line;
					obj[1] = result2.ToString();
					obj[2] = ": '";
					obj[3] = item.Name;
					obj[4] = "' needs Off, Resources or Full; the default stays";
					list.Add(string.Concat(obj));
				}
			}
			return new DungeonsFile(dictionary, list);
		}

		public static Dictionary<string, DungeonMode>? WithMissing(IReadOnlyDictionary<string, DungeonMode> written, IEnumerable<string> generators)
		{
			Dictionary<string, DungeonMode> dictionary = written.ToDictionary<KeyValuePair<string, DungeonMode>, string, DungeonMode>((KeyValuePair<string, DungeonMode> p) => p.Key, (KeyValuePair<string, DungeonMode> p) => p.Value, StringComparer.Ordinal);
			int count = dictionary.Count;
			foreach (string generator in generators)
			{
				if (!string.IsNullOrEmpty(generator) && !dictionary.ContainsKey(generator))
				{
					dictionary[generator] = DungeonModes.Default(generator);
				}
			}
			if (dictionary.Count != count)
			{
				return dictionary;
			}
			return null;
		}

		public static string Write(IReadOnlyDictionary<string, DungeonMode> modes)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("# Delve dungeon modes: Off, Resources (partial regrow and boss return) or Full (wipe and regenerate).\n");
			stringBuilder.Append("# Types not listed keep Delve's default (Resources where something regrows, Off otherwise).\n");
			stringBuilder.Append("modes:\n");
			foreach (KeyValuePair<string, DungeonMode> item in modes.OrderBy<KeyValuePair<string, DungeonMode>, string>((KeyValuePair<string, DungeonMode> p) => p.Key, StringComparer.Ordinal))
			{
				stringBuilder.Append("  ").Append(item.Key).Append(": ")
					.Append(item.Value)
					.Append('\n');
			}
			return stringBuilder.ToString();
		}
	}
	public static class MiniJson
	{
		private sealed class Reader
		{
			private const int MaxDepth = 64;

			private readonly string s;

			private int i;

			public bool End => i >= s.Length;

			public Reader(string text)
			{
				s = text;
			}

			public FormatException Error(string what)
			{
				return new FormatException("JSON " + what + " at offset " + i + ".");
			}

			public void Space()
			{
				while (i < s.Length && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r'))
				{
					i++;
				}
			}

			public object? Value(int depth)
			{
				if (depth > 64)
				{
					throw Error("nesting too deep");
				}
				if (End)
				{
					throw Error("value expected");
				}
				char c = s[i];
				switch (c)
				{
				case '{':
					return Object(depth);
				case '[':
					return Array(depth);
				case '"':
					return String();
				default:
					if (Word("true"))
					{
						return true;
					}
					if (Word("false"))
					{
						return false;
					}
					if (Word("null"))
					{
						return null;
					}
					switch (c)
					{
					case '-':
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
						return Number();
					default:
						throw Error("value expected");
					}
				}
			}

			private bool Word(string word)
			{
				if (string.CompareOrdinal(s, i, word, 0, word.Length) != 0)
				{
					return false;
				}
				i += word.Length;
				return true;
			}

			private double Number()
			{
				int num = i;
				if (s[i] == '-')
				{
					i++;
				}
				while (i < s.Length && "0123456789.eE+-".IndexOf(s[i]) >= 0)
				{
					i++;
				}
				if (!double.TryParse(s.Substring(num, i - num), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					throw Error("bad number");
				}
				return result;
			}

			private string String()
			{
				i++;
				StringBuilder stringBuilder = new StringBuilder();
				while (!End)
				{
					char c = s[i++];
					switch (c)
					{
					case '"':
						return stringBuilder.ToString();
					default:
						stringBuilder.Append(c);
						break;
					case '\\':
						if (End)
						{
							throw Error("bad escape");
						}
						switch (s[i++])
						{
						case '"':
							stringBuilder.Append('"');
							break;
						case '\\':
							stringBuilder.Append('\\');
							break;
						case '/':
							stringBuilder.Append('/');
							break;
						case 'b':
							stringBuilder.Append('\b');
							break;
						case 'f':
							stringBuilder.Append('\f');
							break;
						case 'n':
							stringBuilder.Append('\n');
							break;
						case 'r':
							stringBuilder.Append('\r');
							break;
						case 't':
							stringBuilder.Append('\t');
							break;
						case 'u':
						{
							if (i + 4 > s.Length || !int.TryParse(s.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
							{
								throw Error("bad unicode escape");
							}
							stringBuilder.Append((char)result);
							i += 4;
							break;
						}
						default:
							throw Error("bad escape");
						}
						break;
					}
				}
				throw Error("unterminated string");
			}

			private IDictionary<string, object?> Object(int depth)
			{
				i++;
				Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal);
				Space();
				if (!End && s[i] == '}')
				{
					i++;
					return dictionary;
				}
				while (true)
				{
					Space();
					if (End || s[i] != '"')
					{
						throw Error("key expected");
					}
					string key = String();
					Space();
					if (End || s[i] != ':')
					{
						throw Error("colon expected");
					}
					i++;
					Space();
					dictionary[key] = Value(depth + 1);
					Space();
					if (End)
					{
						throw Error("unterminated object");
					}
					if (s[i] != ',')
					{
						break;
					}
					i++;
				}
				if (s[i] == '}')
				{
					i++;
					return dictionary;
				}
				throw Error("comma or brace expected");
			}

			private IList<object?> Array(int depth)
			{
				i++;
				List<object> list = new List<object>();
				Space();
				if (!End && s[i] == ']')
				{
					i++;
					return list;
				}
				while (true)
				{
					Space();
					list.Add(Value(depth + 1));
					Space();
					if (End)
					{
						throw Error("unterminated array");
					}
					if (s[i] != ',')
					{
						break;
					}
					i++;
				}
				if (s[i] == ']')
				{
					i++;
					return list;
				}
				throw Error("comma or bracket expected");
			}
		}

		public static object? Parse(string text)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			Reader reader = new Reader(text);
			reader.Space();
			object? result = reader.Value(0);
			reader.Space();
			if (!reader.End)
			{
				throw reader.Error("trailing text");
			}
			return result;
		}

		public static string Write(object? value)
		{
			StringBuilder stringBuilder = new StringBuilder();
			WriteValue(stringBuilder, value, 0);
			stringBuilder.Append('\n');
			return stringBuilder.ToString();
		}

		private static void WriteValue(StringBuilder text, object? value, int depth)
		{
			if (value != null)
			{
				if (!(value is bool flag))
				{
					if (!(value is string s))
					{
						if (!(value is double d))
						{
							if (!(value is float num))
							{
								if (!(value is int num2))
								{
									if (!(value is long num3))
									{
										if (!(value is IDictionary<string, object> dictionary))
										{
											if (value is IEnumerable enumerable)
											{
												text.Append('[');
												bool flag2 = false;
												foreach (object item in enumerable)
												{
													if (flag2)
													{
														text