using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using ExtraPotions.Shepherd.Breeding;
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.21.0")]
[assembly: AssemblyInformationalVersion("0.1.21")]
[assembly: AssemblyProduct("Shepherd.Core")]
[assembly: AssemblyTitle("Shepherd.Core")]
[assembly: AssemblyVersion("0.1.21.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.Shepherd
{
	public static class ShepherdCore
	{
		public const string ProductId = "com.meadworks.shepherd";

		public const string Name = "Shepherd";

		public const string Version = "0.1.21";

		public const string Family = "Hearth";

		public const string SupportedGameVersion = "1.0.17";

		public const string KeyPrefix = "shepherd.";
	}
	public static class ShepherdText
	{
		public const string Namespace = "shepherd";

		public const string HerdRoom = "herd_room";

		public const string HerdWaiting = "herd_waiting";

		public const string HerdUnlimited = "herd_unlimited";

		public const string PieceFeedBarrel = "piece_feed_barrel";

		public const string PiecePlankTrough = "piece_plank_trough";

		public const string PieceStoneTrough = "piece_stone_trough";

		public const string PieceTroughDescription = "piece_trough_description";

		private static readonly string[] keys = new string[83]
		{
			"herd_room", "herd_waiting", "herd_unlimited", "piece_feed_barrel", "piece_plank_trough", "piece_stone_trough", "piece_trough_description", "time_seconds", "time_minutes", "time_hours_minutes",
			"lore_taming_gate", "lore_taming", "lore_fed", "lore_content", "lore_love", "lore_pregnant", "lore_due", "lore_generation", "lore_parents", "lore_unknown",
			"lore_growing", "lore_grown_due", "lore_hatching", "lore_hatched_due", "callout_strong", "callout_twins", "book_title", "book_count", "book_close", "book_hungry",
			"book_fed", "book_pregnant", "book_summary", "book_previous", "book_next", "book_rename", "book_rename_reach", "book_empty", "book_empty_title", "book_empty_hint",
			"book_species", "book_stars", "book_variant", "book_state", "book_lineage", "book_generation", "book_born", "book_breeder", "book_mother", "book_sire",
			"book_grandparents", "book_traits", "trough_stock", "trough_last", "trough_no_meal", "trough_foods", "trough_food_only", "piece_land_pen", "piece_land_pen_description", "land_pen_capacity",
			"book_help_previous", "book_help_next", "book_help_close", "book_help_animal", "step_aside_feeding", "step_aside_husbandry", "step_aside_inheritance", "step_aside_containers", "import_done", "command_help",
			"command_off", "command_busy", "command_target", "command_sent", "command_unknown", "command_done", "command_refused", "feed_mark_hint", "feed_mark_on", "feed_mark_off",
			"feed_mark_busy", "feed_mark_refused", "feed_mark_unknown"
		};

		public static IReadOnlyList<string> Keys => keys;

		public static string Token(string key)
		{
			return "$meadworks_shepherd_" + key;
		}
	}
}
namespace ExtraPotions.Shepherd.Yield
{
	public static class HoneyProductionMath
	{
		public static bool Finite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		public static float SecondsPerHoney(float fixedPerDay, bool perPlayer, int online, float daySeconds)
		{
			if (!Finite(daySeconds) || daySeconds <= 0f)
			{
				return 0f;
			}
			float num = (perPlayer ? ((float)Math.Max(1, online)) : (Finite(fixedPerDay) ? Math.Max(0f, Math.Min(1000f, fixedPerDay)) : 0f));
			float num2 = ((num > 0f) ? (daySeconds / num) : 0f);
			if (!Finite(num2) || !(num2 > 0f))
			{
				return 0f;
			}
			return num2;
		}

		public static bool TryRescale(float product, float fromSeconds, float toSeconds, out float scaled)
		{
			scaled = product;
			if (!Finite(product) || product < 0f || !Finite(fromSeconds) || fromSeconds <= 0f || !Finite(toSeconds) || toSeconds <= 0f)
			{
				return false;
			}
			float num = (float)((double)product * (double)toSeconds / (double)fromSeconds);
			if (!Finite(num))
			{
				return false;
			}
			scaled = num;
			return true;
		}

		public static bool TryNativeRemainder(float product, float elapsed, float seconds, out float total, out float remainder)
		{
			total = product + elapsed;
			remainder = product;
			if (!Finite(product) || product < 0f || !Finite(elapsed) || elapsed < 0f || !Finite(seconds) || seconds <= 0f || !Finite(total) || (double)total / (double)seconds >= 2147483647.0)
			{
				return false;
			}
			remainder = ((total > seconds) ? (total - (float)(int)(total / seconds) * seconds) : total);
			if (Finite(remainder))
			{
				return remainder >= 0f;
			}
			return false;
		}
	}
	public enum ProduceStep
	{
		Start,
		Wait,
		Roll
	}
	public readonly struct ProduceTick
	{
		public ProduceStep Step { get; }

		public long NextMs { get; }

		public ProduceTick(ProduceStep step, long nextMs)
		{
			Step = step;
			NextMs = nextMs;
		}
	}
	public static class ProduceClock
	{
		public static ProduceTick Step(long nowMs, long nextMs, double intervalSeconds, double chance)
		{
			long num = (long)Math.Max(1000.0, intervalSeconds * 1000.0);
			if (nextMs == 0L || nextMs - nowMs > num)
			{
				return new ProduceTick(ProduceStep.Start, nowMs + num);
			}
			if (nowMs < nextMs || chance <= 0.0)
			{
				return new ProduceTick(ProduceStep.Wait, nextMs);
			}
			return new ProduceTick(ProduceStep.Roll, nowMs + num);
		}
	}
	public static class YieldMath
	{
		public const int MaxAmount = 100;

		public const double MaxToughness = 0.9;

		public static int Butchered(int amount, double share, IBreedingRandom random)
		{
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			if (amount <= 0 || share <= 0.0)
			{
				return amount;
			}
			double num = (double)amount * (1.0 + share);
			int num2 = (int)Math.Floor(num);
			double num3 = num - (double)num2;
			if (num3 > 0.0 && random.Value() < num3)
			{
				num2++;
			}
			return Math.Min(Math.Max(num2, amount), Math.Max(amount, 100));
		}

		public static int PickWeighted(double[] weights, double unit)
		{
			if (weights == null)
			{
				return -1;
			}
			double num = 0.0;
			int num2 = -1;
			for (int i = 0; i < weights.Length; i++)
			{
				if (weights[i] > 0.0)
				{
					num += weights[i];
					num2 = i;
				}
			}
			if (num2 < 0)
			{
				return -1;
			}
			double num3 = Math.Min(Math.Max(unit, 0.0), 1.0) * num;
			for (int j = 0; j < weights.Length; j++)
			{
				if (!(weights[j] <= 0.0))
				{
					num3 -= weights[j];
					if (num3 < 0.0)
					{
						return j;
					}
				}
			}
			return num2;
		}

		public static bool IsProduce(bool trophy, double foodValue, bool cookingInput)
		{
			if (!trophy && foodValue == 0.0)
			{
				return !cookingInput;
			}
			return false;
		}

		public static int ExtraHoney(int count, double share, IBreedingRandom random)
		{
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			if (count <= 0 || share <= 0.0)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				if (random.Value() < share)
				{
					num++;
				}
			}
			return num;
		}

		public static double PackDealt(double share)
		{
			return 1.0 + Math.Max(0.0, share);
		}

		public static double PackTaken(double share)
		{
			return 1.0 - Math.Min(Math.Max(0.0, share), 0.9);
		}
	}
}
namespace ExtraPotions.Shepherd.Troughs
{
	public sealed class TroughPiece
	{
		public string Prefab { get; }

		public string DisplayName { get; }

		public string Description { get; }

		public string SourcePrefab { get; }

		public string? MeshPrefab { get; }

		public int Width { get; }

		public int Height { get; }

		public string Station { get; }

		public string DefaultRecipe { get; }

		public string NameKey { get; }

		public string DescriptionKey => "piece_trough_description";

		public string NameToken => ShepherdText.Token(NameKey);

		public string DescriptionToken => ShepherdText.Token(DescriptionKey);

		public TroughPiece(string prefab, string nameKey, string displayName, string description, string sourcePrefab, string? meshPrefab, int width, int height, string station, string defaultRecipe)
		{
			Prefab = prefab;
			NameKey = nameKey;
			DisplayName = displayName;
			Description = description;
			SourcePrefab = sourcePrefab;
			MeshPrefab = meshPrefab;
			Width = width;
			Height = height;
			Station = station;
			DefaultRecipe = defaultRecipe;
		}
	}
	public static class TroughCatalog
	{
		public const string Workbench = "piece_workbench";

		public const string Stonecutter = "piece_stonecutter";

		private const string Feeds = "Hungry tamed animals, and animals being tamed, come to eat the food you put in it.";

		private static readonly TroughPiece[] All = new TroughPiece[3]
		{
			new TroughPiece("shepherd_feed_barrel", "piece_feed_barrel", "Feed Barrel", "Hungry tamed animals, and animals being tamed, come to eat the food you put in it.", "piece_chest_barrel", null, 4, 2, "piece_workbench", "Wood:10, LeatherScraps:4"),
			new TroughPiece("shepherd_trough_plank", "piece_plank_trough", "Plank Trough", "Hungry tamed animals, and animals being tamed, come to eat the food you put in it.", "piece_chest_wood", "wood_beam_1", 6, 1, "piece_workbench", "Wood:6, Resin:2"),
			new TroughPiece("shepherd_trough_stone", "piece_stone_trough", "Stone Trough", "Hungry tamed animals, and animals being tamed, come to eat the food you put in it.", "piece_chest_wood", "stone_wall_1x1", 6, 1, "piece_stonecutter", "Stone:12, Wood:2")
		};

		public static IReadOnlyList<TroughPiece> Pieces => All;

		public static TroughPiece? Find(string? prefab)
		{
			string text = Canonical(prefab);
			TroughPiece[] all = All;
			foreach (TroughPiece troughPiece in all)
			{
				if (troughPiece.Prefab == text)
				{
					return troughPiece;
				}
			}
			return null;
		}

		public static string? Canonical(string? prefab)
		{
			if (prefab == "grindstone_feeder")
			{
				return "shepherd_feed_barrel";
			}
			TroughPiece[] all = All;
			for (int i = 0; i < all.Length; i++)
			{
				if (all[i].Prefab == prefab)
				{
					return prefab;
				}
			}
			return null;
		}
	}
	public static class TroughSource
	{
		public static readonly IReadOnlyList<string> Fallbacks = new string[5] { "piece_chest_wood", "piece_chest_barrel", "piece_chest", "piece_chest_private", "piece_chest_blackmetal" };

		public static IEnumerable<string> Candidates(string? preferred)
		{
			if (!string.IsNullOrEmpty(preferred))
			{
				yield return preferred;
			}
			foreach (string fallback in Fallbacks)
			{
				if (fallback != preferred)
				{
					yield return fallback;
				}
			}
		}

		public static string? Choose(string? preferred, Func<string, bool> usable)
		{
			foreach (string item in Candidates(preferred))
			{
				if (usable(item))
				{
					return item;
				}
			}
			return null;
		}
	}
	public static class TroughGate
	{
		public const double HiddenAbove = 100.0;

		public static bool MayBuild(double buildLevel, double keeperLevel, bool husbandryActive)
		{
			if (buildLevel > 100.0)
			{
				return false;
			}
			if (buildLevel <= 0.0)
			{
				return true;
			}
			if (husbandryActive)
			{
				return keeperLevel >= buildLevel;
			}
			return false;
		}
	}
	public static class TroughFilter
	{
		public static bool Accepts(string? itemPrefab, ISet<string> edible)
		{
			if (!string.IsNullOrEmpty(itemPrefab) && edible != null)
			{
				return edible.Contains(itemPrefab);
			}
			return false;
		}
	}
	public static class TroughPrefabs
	{
		public const string FeedBarrel = "shepherd_feed_barrel";

		public const string PlankTrough = "shepherd_trough_plank";

		public const string StoneTrough = "shepherd_trough_stone";

		public const string GrindstoneFeeder = "grindstone_feeder";

		public const string FeedRole = "feed";

		private static readonly HashSet<string> Names = new HashSet<string>(StringComparer.Ordinal) { "shepherd_feed_barrel", "shepherd_trough_plank", "shepherd_trough_stone", "grindstone_feeder" };

		public static IReadOnlyCollection<string> All => Names;

		public static bool IsTrough(string? prefabName)
		{
			if (prefabName != null)
			{
				return Names.Contains(prefabName);
			}
			return false;
		}

		public static string? RoleOf(string? prefabName)
		{
			if (!IsTrough(prefabName))
			{
				return null;
			}
			return "feed";
		}
	}
	public readonly struct RecipeEntry
	{
		public string Item { get; }

		public int Amount { get; }

		public RecipeEntry(string item, int amount)
		{
			Item = item;
			Amount = amount;
		}
	}
	public static class TroughRecipe
	{
		public const string Fallback = "Wood:10";

		public static IReadOnlyList<RecipeEntry> Parse(string? text, Func<string, bool> knownItem)
		{
			if (knownItem == null)
			{
				throw new ArgumentNullException("knownItem");
			}
			List<RecipeEntry> list = Read(text, knownItem);
			if (list.Count <= 0)
			{
				return Read("Wood:10", (string _) => true);
			}
			return list;
		}

		private static List<RecipeEntry> Read(string? text, Func<string, bool> knownItem)
		{
			List<RecipeEntry> list = new List<RecipeEntry>();
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(':');
				if (array2.Length == 2 && int.TryParse(array2[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result >= 1)
				{
					string text2 = array2[0].Trim();
					if (text2.Length != 0 && knownItem(text2))
					{
						list.Add(new RecipeEntry(text2, result));
					}
				}
			}
			return list;
		}
	}
}
namespace ExtraPotions.Shepherd.Take
{
	public static class TakeProtocol
	{
		public const string TakeRpc = "shepherd.take";

		public const string MealRpc = "shepherd.meal";

		public const double ReplyTimeoutSeconds = 10.0;

		public const double DedupeWindowSeconds = 60.0;

		public const int DedupeCapacity = 256;

		public const int MaxItemNameLength = 128;

		internal const string Version = "v1";

		internal const char Separator = '|';
	}
	public readonly struct NetObjectId : IEquatable<NetObjectId>
	{
		public long User { get; }

		public uint Id { get; }

		public bool IsNone
		{
			get
			{
				if (User == 0L)
				{
					return Id == 0;
				}
				return false;
			}
		}

		public NetObjectId(long user, uint id)
		{
			User = user;
			Id = id;
		}

		public bool Equals(NetObjectId other)
		{
			if (User == other.User)
			{
				return Id == other.Id;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (User.GetHashCode() * 397) ^ (int)Id;
		}

		public override string ToString()
		{
			return User.ToString(CultureInfo.InvariantCulture) + ":" + Id.ToString(CultureInfo.InvariantCulture);
		}

		public static bool TryParse(string? text, out NetObjectId value)
		{
			value = default(NetObjectId);
			if (!IdText.TryPair(text, out var first, out var second))
			{
				return false;
			}
			value = new NetObjectId(first, second);
			return true;
		}
	}
	public readonly struct TakeRequestId : IEquatable<TakeRequestId>
	{
		public long Issuer { get; }

		public uint Sequence { get; }

		public TakeRequestId(long issuer, uint sequence)
		{
			Issuer = issuer;
			Sequence = sequence;
		}

		public bool Equals(TakeRequestId other)
		{
			if (Issuer == other.Issuer)
			{
				return Sequence == other.Sequence;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (Issuer.GetHashCode() * 397) ^ (int)Sequence;
		}

		public override string ToString()
		{
			return Issuer.ToString(CultureInfo.InvariantCulture) + ":" + Sequence.ToString(CultureInfo.InvariantCulture);
		}

		public static bool TryParse(string? text, out TakeRequestId value)
		{
			value = default(TakeRequestId);
			if (!IdText.TryPair(text, out var first, out var second))
			{
				return false;
			}
			value = new TakeRequestId(first, second);
			return true;
		}
	}
	public sealed class TakeRequest
	{
		public TakeRequestId Id { get; }

		public string ItemName { get; }

		public NetObjectId Animal { get; }

		public TakeRequest(TakeRequestId id, string itemName, NetObjectId animal)
		{
			Id = id;
			ItemName = itemName ?? throw new ArgumentNullException("itemName");
			Animal = animal;
		}
	}
	public sealed class MealMessage
	{
		public TakeRequestId Id { get; }

		public string ItemName { get; }

		public MealMessage(TakeRequestId id, string itemName)
		{
			Id = id;
			ItemName = itemName ?? throw new ArgumentNullException("itemName");
		}
	}
	public static class TakeCodec
	{
		private const string TakeKind = "take";

		private const string MealKind = "meal";

		public static string Encode(TakeRequest request)
		{
			if (request == null)
			{
				throw new ArgumentNullException("request");
			}
			RequireItem(request.ItemName);
			return string.Join('|'.ToString(), "v1", "take", request.Id.ToString(), request.Animal.ToString(), request.ItemName);
		}

		public static string Encode(MealMessage meal)
		{
			if (meal == null)
			{
				throw new ArgumentNullException("meal");
			}
			RequireItem(meal.ItemName);
			return string.Join('|'.ToString(), "v1", "meal", meal.Id.ToString(), meal.ItemName);
		}

		public static bool TryDecodeTake(string? text, out TakeRequest? request)
		{
			request = null;
			string[] array = Split(text, "take", 5);
			if (array == null || !TakeRequestId.TryParse(array[2], out var value) || !NetObjectId.TryParse(array[3], out var value2) || !IsItem(array[4]))
			{
				return false;
			}
			request = new TakeRequest(value, array[4], value2);
			return true;
		}

		public static bool TryDecodeMeal(string? text, out MealMessage? meal)
		{
			meal = null;
			string[] array = Split(text, "meal", 4);
			if (array == null || !TakeRequestId.TryParse(array[2], out var value) || !IsItem(array[3]))
			{
				return false;
			}
			meal = new MealMessage(value, array[3]);
			return true;
		}

		public static bool IsItem(string? item)
		{
			if (!string.IsNullOrEmpty(item) && item.Length <= 128)
			{
				return item.IndexOf('|') < 0;
			}
			return false;
		}

		private static void RequireItem(string item)
		{
			if (!IsItem(item))
			{
				throw new ArgumentException("An item name is 1 to " + 128 + " characters without '|'.", "item");
			}
		}

		private static string[]? Split(string? text, string kind, int count)
		{
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			string[] array = text.Split('|');
			if (array.Length != count || !(array[0] == "v1") || !(array[1] == kind))
			{
				return null;
			}
			return array;
		}
	}
	internal static class IdText
	{
		public static bool TryPair(string? text, out long first, out uint second)
		{
			first = 0L;
			second = 0u;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			int num = text.IndexOf(':');
			if (num <= 0 || num != text.LastIndexOf(':'))
			{
				return false;
			}
			if (long.TryParse(text.Substring(0, num), NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out first))
			{
				return uint.TryParse(text.Substring(num + 1), NumberStyles.None, CultureInfo.InvariantCulture, out second);
			}
			return false;
		}
	}
	public enum MealDecision
	{
		Apply,
		Duplicate,
		NotOwner
	}
	public sealed class TakeRequester
	{
		private readonly long issuer;

		private readonly double timeout;

		private readonly Dictionary<NetObjectId, (TakeRequest Request, double At)> pending = new Dictionary<NetObjectId, (TakeRequest, double)>();

		private readonly HashSet<TakeRequestId> applied = new HashSet<TakeRequestId>();

		private uint sequence;

		public int PendingCount => pending.Count;

		public TakeRequester(long issuer, double timeout = 10.0)
		{
			if (!(timeout > 0.0))
			{
				throw new ArgumentOutOfRangeException("timeout");
			}
			this.issuer = issuer;
			this.timeout = timeout;
		}

		public bool HasPending(NetObjectId animal)
		{
			return pending.ContainsKey(animal);
		}

		public bool IsBlocking(NetObjectId animal, double now)
		{
			if (pending.TryGetValue(animal, out (TakeRequest, double) value))
			{
				return now - value.Item2 < timeout;
			}
			return false;
		}

		public TakeRequest? TryBegin(NetObjectId animal, string itemName, double now)
		{
			if (!TakeCodec.IsItem(itemName))
			{
				throw new ArgumentException("Invalid item name.", "itemName");
			}
			if (pending.TryGetValue(animal, out (TakeRequest, double) value))
			{
				if (now - value.Item2 < timeout)
				{
					return null;
				}
				pending[animal] = (value.Item1, now);
				return value.Item1;
			}
			if (sequence == uint.MaxValue)
			{
				throw new InvalidOperationException("Request sequence exhausted for this session.");
			}
			TakeRequest takeRequest = new TakeRequest(new TakeRequestId(issuer, ++sequence), itemName, animal);
			pending[animal] = (takeRequest, now);
			return takeRequest;
		}

		public IReadOnlyList<TakeRequest> Expire(double now)
		{
			return Array.Empty<TakeRequest>();
		}

		public void Forget(NetObjectId animal)
		{
			pending.Remove(animal);
		}

		public MealDecision OnMeal(MealMessage meal, NetObjectId animal, bool ownedHere, double now)
		{
			if (meal == null)
			{
				throw new ArgumentNullException("meal");
			}
			if (!ownedHere)
			{
				return MealDecision.NotOwner;
			}
			if (!applied.Add(meal.Id))
			{
				return MealDecision.Duplicate;
			}
			if (pending.TryGetValue(animal, out (TakeRequest, double) value) && value.Item1.Id.Equals(meal.Id))
			{
				pending.Remove(animal);
			}
			return MealDecision.Apply;
		}
	}
	public enum TakeRoute
	{
		None,
		Local,
		Remote
	}
	public static class TakeRouting
	{
		public const bool ClaimsOwnership = false;

		public static TakeRoute ForTake(bool troughValid, long troughOwner, long localPeer)
		{
			return Route(troughValid, troughOwner, localPeer);
		}

		public static TakeRoute ForMeal(bool animalValid, long animalOwner, long localPeer)
		{
			return Route(animalValid, animalOwner, localPeer);
		}

		private static TakeRoute Route(bool valid, long owner, long local)
		{
			if (!valid || owner == 0L)
			{
				return TakeRoute.None;
			}
			if (owner != local)
			{
				return TakeRoute.Remote;
			}
			return TakeRoute.Local;
		}
	}
	public sealed class DedupeRing
	{
		private readonly int capacity;

		private readonly double window;

		private readonly Queue<(TakeRequestId Id, double At)> order = new Queue<(TakeRequestId, double)>();

		private readonly Dictionary<TakeRequestId, double> seen = new Dictionary<TakeRequestId, double>();

		public int Count => seen.Count;

		public DedupeRing(int capacity = 256, double window = 60.0)
		{
			if (capacity <= 0)
			{
				throw new ArgumentOutOfRangeException("capacity");
			}
			if (!(window > 0.0))
			{
				throw new ArgumentOutOfRangeException("window");
			}
			this.capacity = capacity;
			this.window = window;
		}

		public bool CheckAndRemember(TakeRequestId id, double now)
		{
			Prune(now);
			if (seen.ContainsKey(id))
			{
				return false;
			}
			while (order.Count >= capacity)
			{
				seen.Remove(order.Dequeue().Id);
			}
			order.Enqueue((id, now));
			seen[id] = now;
			return true;
		}

		public void Forget(TakeRequestId id)
		{
			if (!seen.Remove(id))
			{
				return;
			}
			int count = order.Count;
			for (int i = 0; i < count; i++)
			{
				(TakeRequestId, double) item = order.Dequeue();
				if (!item.Item1.Equals(id))
				{
					order.Enqueue(item);
				}
			}
		}

		private void Prune(double now)
		{
			while (order.Count > 0 && now - order.Peek().At >= window)
			{
				seen.Remove(order.Dequeue().Id);
			}
		}
	}
	public enum TakeVerdict
	{
		Granted,
		Resend,
		Duplicate,
		NotOwner,
		TroughGone,
		TroughDisabled,
		ItemMissing,
		ItemDisallowed
	}
	public static class TakeVerdicts
	{
		public static bool RemovesItem(TakeVerdict verdict)
		{
			return verdict == TakeVerdict.Granted;
		}

		public static bool SendsMeal(TakeVerdict verdict)
		{
			if (verdict != TakeVerdict.Granted)
			{
				return verdict == TakeVerdict.Resend;
			}
			return true;
		}
	}
	public readonly struct TroughFacts
	{
		public bool Exists { get; }

		public bool IsOwner { get; }

		public bool Enabled { get; }

		public bool HasItem { get; }

		public bool Disallowed { get; }

		public TroughFacts(bool exists, bool isOwner, bool enabled, bool hasItem, bool disallowed)
		{
			Exists = exists;
			IsOwner = isOwner;
			Enabled = enabled;
			HasItem = hasItem;
			Disallowed = disallowed;
		}
	}
	public sealed class TakeServer
	{
		private readonly DedupeRing ring;

		private readonly HashSet<TakeRequestId> granted = new HashSet<TakeRequestId>();

		public TakeServer(DedupeRing? ring = null)
		{
			this.ring = ring ?? new DedupeRing();
		}

		public TakeVerdict Decide(TakeRequest request, TroughFacts facts, double now)
		{
			if (request == null)
			{
				throw new ArgumentNullException("request");
			}
			if (!facts.Exists)
			{
				return TakeVerdict.TroughGone;
			}
			if (!facts.IsOwner)
			{
				return TakeVerdict.NotOwner;
			}
			if (granted.Contains(request.Id))
			{
				return TakeVerdict.Resend;
			}
			if (!facts.Enabled)
			{
				return TakeVerdict.TroughDisabled;
			}
			if (facts.Disallowed)
			{
				return TakeVerdict.ItemDisallowed;
			}
			if (!facts.HasItem)
			{
				return TakeVerdict.ItemMissing;
			}
			if (!ring.CheckAndRemember(request.Id, now))
			{
				return TakeVerdict.Duplicate;
			}
			return TakeVerdict.Granted;
		}

		public void Commit(TakeRequestId id)
		{
			granted.Add(id);
		}

		public void Release(TakeRequestId id)
		{
			granted.Remove(id);
			ring.Forget(id);
		}
	}
}
namespace ExtraPotions.Shepherd.Pens
{
	public static class LandPenDefinition
	{
		public const string Prefab = "shepherd_land_pen";

		public const string NativeGate = "wood_gate";

		public const string DefaultRecipe = "Wood:30, Resin:4";

		public const string Station = "piece_workbench";

		public const int DefaultCapacity = 12;

		public const int MaximumCapacity = 100;

		public const float Width = 6f;

		public const float Length = 6f;

		public const float Height = 3f;

		public const float RailHeight = 1.5f;

		public const string NameKey = "piece_land_pen";

		public const string DescriptionKey = "piece_land_pen_description";

		public const string CapacityKey = "land_pen_capacity";

		public static int Capacity(int value)
		{
			if (value >= 0)
			{
				if (value <= 100)
				{
					return value;
				}
				return 100;
			}
			return 0;
		}
	}
	public static class PenCapacity
	{
		public static int Maximum(int native, int? pen)
		{
			if (!pen.HasValue || pen.Value <= 0)
			{
				return native;
			}
			return pen.Value;
		}
	}
}
namespace ExtraPotions.Shepherd.Husbandry
{
	public static class FollowRules
	{
		public static bool Enables(bool active, bool nativelyCommandable, bool summon, bool supportsFollow)
		{
			return active && !nativelyCommandable && !summon && supportsFollow;
		}

		public static bool Restores(bool flippedByShepherd, bool active)
		{
			if (flippedByShepherd)
			{
				return !active;
			}
			return false;
		}

		public static bool PetsForContent(bool nativelyCommandable)
		{
			return !nativelyCommandable;
		}
	}
	public readonly struct HerdSnapshot
	{
		public float TamingLeft { get; }

		public float TamingTime { get; }

		public bool Tamed { get; }

		public long LastFed { get; }

		public int Births { get; }

		public bool BeingTamed
		{
			get
			{
				if (!Tamed)
				{
					return TamingLeft < TamingTime;
				}
				return false;
			}
		}

		public HerdSnapshot(float tamingLeft, float tamingTime, bool tamed, long lastFed, int births)
		{
			TamingTime = Math.Max(1f, tamingTime);
			Tamed = tamed;
			TamingLeft = (tamed ? 0f : tamingLeft);
			LastFed = lastFed;
			Births = births;
		}
	}
	public readonly struct ExperienceRates
	{
		public double Taming { get; }

		public double Tamed { get; }

		public double Discovery { get; }

		public double Feeding { get; }

		public double Birth { get; }

		public ExperienceRates(double taming, double tamed, double discovery, double feeding, double birth)
		{
			Taming = Math.Max(0.0, taming);
			Tamed = Math.Max(0.0, tamed);
			Discovery = Math.Max(1.0, discovery);
			Feeding = Math.Max(0.0, feeding);
			Birth = Math.Max(0.0, birth);
		}
	}
	public static class HerdExperience
	{
		public const int MaxBirthsPerScan = 4;

		public static double Between(HerdSnapshot before, HerdSnapshot now, ExperienceRates rates, Func<bool> firstOfKind)
		{
			if (firstOfKind == null)
			{
				throw new ArgumentNullException("firstOfKind");
			}
			double num = Taming(before, now, rates) + Tamed(before, now, rates, firstOfKind);
			if (now.LastFed != before.LastFed && now.LastFed != 0L && (now.Tamed || now.BeingTamed))
			{
				num += rates.Feeding;
			}
			int num2 = Math.Min(4, Math.Max(0, now.Births - before.Births));
			return num + (double)num2 * rates.Birth;
		}

		private static double Taming(HerdSnapshot before, HerdSnapshot now, ExperienceRates rates)
		{
			if (before.Tamed || now.Tamed || now.TamingLeft >= before.TamingLeft)
			{
				return 0.0;
			}
			return (double)(before.TamingLeft - now.TamingLeft) / (double)now.TamingTime * rates.Taming;
		}

		private static double Tamed(HerdSnapshot before, HerdSnapshot now, ExperienceRates rates, Func<bool> firstOfKind)
		{
			if (!now.Tamed || !before.BeingTamed)
			{
				return 0.0;
			}
			if (!firstOfKind())
			{
				return rates.Tamed;
			}
			return rates.Tamed * rates.Discovery;
		}
	}
	public static class TameDiscovery
	{
		public const string Key = "shepherd.tamed_kinds";

		public const string GrindstoneKey = "grindstone_tamed";

		private const char Separator = ',';

		public static bool HasTamed(IDictionary<string, string> data, string prefab)
		{
			if (data != null && !string.IsNullOrEmpty(prefab))
			{
				if (!Listed(data, "shepherd.tamed_kinds", prefab))
				{
					return Listed(data, "grindstone_tamed", prefab);
				}
				return true;
			}
			return false;
		}

		public static bool TryRecord(IDictionary<string, string> data, string prefab)
		{
			if (data == null || string.IsNullOrEmpty(prefab) || prefab.IndexOf(',') >= 0 || HasTamed(data, prefab))
			{
				return false;
			}
			data.TryGetValue("shepherd.tamed_kinds", out string value);
			data["shepherd.tamed_kinds"] = (string.IsNullOrEmpty(value) ? prefab : (value + "," + prefab));
			return true;
		}

		private static bool Listed(IDictionary<string, string> data, string key, string prefab)
		{
			if (data.TryGetValue(key, out string value))
			{
				return Array.IndexOf((value ?? "").Split(','), prefab) >= 0;
			}
			return false;
		}
	}
	public static class HusbandryIdentity
	{
		public const string Identity = "meadworks_husbandry";

		public const string PublishKey = "meadworks_husbandry_level";

		public const string ImportFrom = "grindstone_husbandry";

		public const string Name = "Husbandry";

		public const string Description = "Tending animals: taming, feeding, breeding and herd care.";

		public const double DefaultKeeperRange = 30.0;
	}
}
namespace ExtraPotions.Shepherd.Feeding
{
	public enum FeederKind
	{
		Trough,
		Container
	}
	public enum ContainerSelectionMode
	{
		AllExceptDenied,
		MarkedOnly
	}
	public readonly struct AnimalFacts
	{
		public bool Tamed { get; }

		public bool BeingTamed { get; }

		public bool Tameable { get; }

		public bool Hungry { get; }

		public bool Dead { get; }

		public bool Disallowed { get; }

		public AnimalFacts(bool tamed, bool beingTamed, bool tameable, bool hungry, bool dead, bool disallowed)
		{
			Tamed = tamed;
			BeingTamed = beingTamed;
			Tameable = tameable;
			Hungry = hungry;
			Dead = dead;
			Disallowed = disallowed;
		}
	}
	public static class NameList
	{
		public static IReadOnlyCollection<string> Parse(string? text)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					hashSet.Add(text2);
				}
			}
			return hashSet;
		}
	}
	public static class FeedingRules
	{
		public static bool Eligible(AnimalFacts animal, bool feedWild)
		{
			if (!animal.Tameable || !animal.Hungry || animal.Dead || animal.Disallowed)
			{
				return false;
			}
			return animal.Tamed || animal.BeingTamed || feedWild;
		}

		public static bool EligibleYoung(AnimalFacts animal, bool feedWild, bool growing, bool nativeEater)
		{
			if (growing && nativeEater && !animal.Tameable && animal.Hungry && !animal.Dead && !animal.Disallowed)
			{
				return animal.Tamed || feedWild;
			}
			return false;
		}

		public static string? FirstFood(IEnumerable<string> consumeItems, Func<string, bool> holds, IReadOnlyCollection<string> disallowed)
		{
			if (consumeItems == null)
			{
				throw new ArgumentNullException("consumeItems");
			}
			if (holds == null)
			{
				throw new ArgumentNullException("holds");
			}
			foreach (string consumeItem in consumeItems)
			{
				if (!string.IsNullOrEmpty(consumeItem) && !IsListed(disallowed, consumeItem) && holds(consumeItem))
				{
					return consumeItem;
				}
			}
			return null;
		}

		public static bool IsListed(IReadOnlyCollection<string>? names, string? name)
		{
			if (names == null || names.Count == 0 || string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (names is ICollection<string> collection)
			{
				return collection.Contains(name);
			}
			foreach (string name2 in names)
			{
				if (string.Equals(name2, name, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
	public readonly struct ContainerFacts
	{
		public bool IsTrough { get; }

		public bool IsPrivate { get; }

		public bool PlayerBuilt { get; }

		public bool? BurrowFeedSource { get; }

		public bool ShepherdMarked { get; }

		public bool ShepherdDenied { get; }

		public ContainerFacts(bool isTrough, bool isPrivate, bool playerBuilt, bool? burrowFeedSource, bool shepherdMarked, bool shepherdDenied)
		{
			IsTrough = isTrough;
			IsPrivate = isPrivate;
			PlayerBuilt = playerBuilt;
			BurrowFeedSource = burrowFeedSource;
			ShepherdMarked = shepherdMarked;
			ShepherdDenied = shepherdDenied;
		}
	}
	public static class ContainerEligibility
	{
		public const string MarkKey = "shepherd.feed";

		public const string DenyKey = "shepherd.feed_deny";

		public static bool IsFeedSource(ContainerFacts facts, ContainerSelectionMode selection)
		{
			if (facts.IsTrough || facts.IsPrivate || !facts.PlayerBuilt)
			{
				return false;
			}
			if (selection == ContainerSelectionMode.MarkedOnly)
			{
				return facts.BurrowFeedSource ?? facts.ShepherdMarked;
			}
			return !facts.ShepherdDenied;
		}
	}
	public readonly struct FeedSolidSpan
	{
		public double Start { get; }

		public double End { get; }

		public FeedSolidSpan(double start, double end)
		{
			Start = start;
			End = end;
		}
	}
	public static class FeedMath
	{
		public const double EatRiseMetres = 1.0;

		public const int RingBearings = 8;

		public const double SpotRecheckSeconds = 2.0;

		public const double DirectWalkMetres = 6.0;

		public const double DirectWalkRise = 1.0;

		public static double SolidThickness(IEnumerable<FeedSolidSpan> solids)
		{
			List<FeedSolidSpan> list = new List<FeedSolidSpan>();
			foreach (FeedSolidSpan solid in solids)
			{
				if (double.IsNaN(solid.Start) || double.IsNaN(solid.End) || double.IsInfinity(solid.Start) || double.IsInfinity(solid.End) || solid.Start < 0.0 || solid.End < solid.Start)
				{
					return double.PositiveInfinity;
				}
				if (solid.End > solid.Start)
				{
					list.Add(solid);
				}
			}
			list.Sort((FeedSolidSpan a, FeedSolidSpan b) => a.Start.CompareTo(b.Start));
			double num = 0.0;
			double num2 = 0.0;
			foreach (FeedSolidSpan item in list)
			{
				if (!(item.End <= num2))
				{
					num += item.End - Math.Max(num2, item.Start);
					num2 = item.End;
				}
			}
			return num;
		}

		public static bool WallWithinReach(double thickness, double configuredMetres)
		{
			double num = (double.IsNaN(configuredMetres) ? 0.0 : Math.Max(0.0, Math.Min(2.0, configuredMetres)));
			if (thickness != 0.0)
			{
				if (thickness > 0.0 && num > 0.0)
				{
					return thickness <= num + 0.0001;
				}
				return false;
			}
			return true;
		}

		public static double StandOff(double sourceRadius, double animalRadius)
		{
			return sourceRadius + animalRadius;
		}

		public static bool InReach(double distance, double sourceRadius, double animalRadius, double proximity)
		{
			return InReach(distance, sourceRadius, animalRadius, proximity, 0.0);
		}

		public static bool InReach(double distance, double sourceRadius, double animalRadius, double proximity, double rise)
		{
			if (Math.Abs(rise) <= 1.0)
			{
				return distance <= StandOff(sourceRadius, animalRadius) + proximity;
			}
			return false;
		}

		public static bool MayEatFrom(double distance, double sourceRadius, double animalRadius, double proximity, bool requireMove, double range)
		{
			return MayEatFrom(distance, sourceRadius, animalRadius, proximity, requireMove, range, 0.0);
		}

		public static bool MayEatFrom(double distance, double sourceRadius, double animalRadius, double proximity, bool requireMove, double range, double rise)
		{
			if (!requireMove)
			{
				return distance <= range;
			}
			return InReach(distance, sourceRadius, animalRadius, proximity, rise);
		}

		public static bool GaveUp(double since, double now, double giveUpSeconds)
		{
			return now - since > giveUpSeconds;
		}

		public static bool MayWalkDirect(double toSpot, double rise)
		{
			if (toSpot >= 0.0 && toSpot <= 6.0)
			{
				return Math.Abs(rise) <= 1.0;
			}
			return false;
		}

		public static IEnumerable<int> RingOrder(int bearings)
		{
			if (bearings <= 0)
			{
				yield break;
			}
			yield return 0;
			for (int step = 1; step <= bearings / 2; step++)
			{
				yield return step;
				if (bearings - step != step)
				{
					yield return bearings - step;
				}
			}
		}
	}
	public sealed class FeedCandidate
	{
		public string Id { get; }

		public FeederKind Kind { get; }

		public double DistanceSquared { get; }

		public string Food { get; }

		public FeedCandidate(string id, FeederKind kind, double distanceSquared, string food)
		{
			Id = id ?? throw new ArgumentNullException("id");
			Kind = kind;
			DistanceSquared = distanceSquared;
			Food = food ?? throw new ArgumentNullException("food");
		}
	}
	public static class FeedSearch
	{
		public const int PathTries = 3;

		public static FeedCandidate? Choose(IEnumerable<FeedCandidate> candidates, Func<FeedCandidate, bool> havePath)
		{
			if (candidates == null)
			{
				throw new ArgumentNullException("candidates");
			}
			if (havePath == null)
			{
				throw new ArgumentNullException("havePath");
			}
			int num = 0;
			foreach (FeedCandidate item in from c in candidates
				orderby (c.Kind != FeederKind.Trough) ? 1 : 0, c.DistanceSquared
				select c)
			{
				if (havePath(item))
				{
					return item;
				}
				if (++num >= 3)
				{
					return null;
				}
			}
			return null;
		}
	}
	public static class YoungMealPacing
	{
		public const double FallbackSeconds = 600.0;

		public static double Interval(double adultSeconds)
		{
			if (!(adultSeconds > 0.0) || double.IsInfinity(adultSeconds) || double.IsNaN(adultSeconds))
			{
				return 600.0;
			}
			return adultSeconds;
		}

		public static bool Due(long nowTicks, long lastMealTicks, double adultSeconds)
		{
			if (nowTicks <= 0)
			{
				return false;
			}
			if (lastMealTicks <= 0)
			{
				return true;
			}
			if (lastMealTicks > nowTicks)
			{
				return false;
			}
			return (double)(nowTicks - lastMealTicks) / 10000000.0 >= Interval(adultSeconds);
		}
	}
}
namespace ExtraPotions.Shepherd.Conversion
{
	public static class SimpleYaml
	{
		public static Dictionary<string, string> Read(string? text)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			List<(int, string)> list = new List<(int, string)>();
			int num = -1;
			string[] array = (text ?? "").Replace("\r", "").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = StripComment(array[i]);
				if (text2.Trim().Length == 0)
				{
					continue;
				}
				int num2 = text2.Length - text2.TrimStart(' ').Length;
				string text3 = text2.Trim();
				if (num >= 0)
				{
					if (num2 > num)
					{
						continue;
					}
					num = -1;
				}
				while (list.Count > 0 && list[list.Count - 1].Item1 >= num2)
				{
					list.RemoveAt(list.Count - 1);
				}
				if (text3.StartsWith("-", StringComparison.Ordinal))
				{
					num = num2;
					continue;
				}
				int num3 = text3.IndexOf(':');
				if (num3 > 0)
				{
					string text4 = text3.Substring(0, num3).Trim();
					string text5 = Unquote(text3.Substring(num3 + 1).Trim());
					string key = string.Join(".", list.Select<(int, string), string>(((int Indent, string Key) s) => s.Key).Concat(new string[1] { text4 }));
					if (text5.Length == 0)
					{
						list.Add((num2, text4));
					}
					else
					{
						dictionary[key] = text5;
					}
				}
			}
			return dictionary;
		}

		public static IReadOnlyList<string> List(string? value)
		{
			string text = (value ?? "").Trim();
			if (text.StartsWith("[", StringComparison.Ordinal) && text.EndsWith("]", StringComparison.Ordinal))
			{
				text = text.Substring(1, text.Length - 2);
			}
			return (from p in text.Split(',')
				select Unquote(p.Trim()) into p
				where p.Length > 0
				select p).ToList();
		}

		private static string StripComment(string line)
		{
			char c = '\0';
			for (int i = 0; i < line.Length; i++)
			{
				char c2 = line[i];
				if (c != 0)
				{
					if (c2 == c)
					{
						c = '\0';
					}
					continue;
				}
				switch (c2)
				{
				case '"':
				case '\'':
					c = c2;
					break;
				case '#':
					if (i == 0 || line[i - 1] == ' ')
					{
						return line.Substring(0, i);
					}
					break;
				}
			}
			return line;
		}

		private static string Unquote(string v)
		{
			if (v.Length < 2 || (v[0] != '\'' && v[0] != '"') || v[v.Length - 1] != v[0])
			{
				return v;
			}
			return v.Substring(1, v.Length - 2);
		}
	}
	public readonly struct SourceEntry
	{
		public string Section { get; }

		public string Key { get; }

		public string Value { get; }

		public SourceEntry(string section, string key, string value)
		{
			Section = section;
			Key = key;
			Value = value;
		}
	}
	public static class SourceConfig
	{
		public static IReadOnlyList<SourceEntry> Parse(string? text)
		{
			List<SourceEntry> list = new List<SourceEntry>();
			string section = "";
			string[] array = (text ?? "").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				if (text2[0] == '[' && text2[text2.Length - 1] == ']')
				{
					section = text2.Substring(1, text2.Length - 2).Trim();
					continue;
				}
				int num = text2.IndexOf('=');
				if (num > 0)
				{
					string text3 = text2.Substring(0, num).Trim();
					if (text3.Length != 0)
					{
						list.Add(new SourceEntry(section, text3, text2.Substring(num + 1).Trim()));
					}
				}
			}
			return list;
		}
	}
	public enum ImportSource
	{
		AutoFeedRedux,
		GrindstoneSkills,
		EliteCreaturesReborn
	}
	public sealed class ImportPlan
	{
		public ImportSource Source { get; }

		public Dictionary<string, string> Values { get; } = new Dictionary<string, string>(StringComparer.Ordinal);

		public List<string> Notes { get; } = new List<string>();

		internal ImportPlan(ImportSource source)
		{
			Source = source;
		}

		public string Report()
		{
			return "Source: " + Source.ToString() + "\n" + string.Join("\n", Values.Select<KeyValuePair<string, string>, string>((KeyValuePair<string, string> v) => "Set " + v.Key + " = " + v.Value).Concat(Notes));
		}
	}
	public static class SourceImport
	{
		private static readonly Dictionary<string, string> mappings = BuildMappings();

		public static string FileName(ImportSource source)
		{
			return source switch
			{
				ImportSource.GrindstoneSkills => "com.GrindstoneSkills.cfg", 
				ImportSource.AutoFeedRedux => "vapok.mods.AutoFeedRedux.cfg", 
				_ => "creature_rules.yml", 
			};
		}

		private static Dictionary<string, string> BuildMappings()
		{
			Dictionary<string, string> map = new Dictionary<string, string>(StringComparer.Ordinal);
			Set("Synced Settings", "Enable Auto Feeder", "2 - Feeding", "Container Feeding");
			Set("Synced Settings", "Feed Range in Meters", "2 - Feeding", "Container Range");
			Set("Synced Settings", "Require Move to Feed", "2 - Feeding", "Require Move To Feed");
			Set("Synced Settings", "Disallow Animal", "2 - Feeding", "Disallow Animals");
			Same("Synced Settings", "2 - Feeding", "Move Proximity|Disallow Feed|Protect Feed Containers");
			Set("23 - Husbandry", "Husbandry Enabled", "1 - General", "Husbandry Enabled");
			Same("23 - Husbandry", "4 - Husbandry", "Keeper Range|Animal Lore Level|Show Callouts");
			Same("24 - Taming", "5 - Taming", "Taming Speed At 100|Fed Duration At 100|Taming Levels|Calm Level|Calm Break Time");
			Same("25 - Breeding", "6 - Breeding", "Breeding Speed At 100|Growth Speed At 100|Better Offspring At 100|Max Offspring Level|Twins At 100|Content Duration|Content Breeding Bonus");
			Set("25 - Breeding", "Herd Size At 100", "7 - Herd", "Herd Size At 100");
			Same("26 - Animal Yield", "8 - Yield", "Butcher Yield At 100|Produce Chance At 100|Produce Interval|Extra Honey At 100");
			Same("27 - Companions", "9 - Companions", "Pack Damage At 100|Pack Toughness At 100");
			Set("27 - Companions", "Feeder Level", "3 - Troughs", "Build Level");
			Set("27 - Companions", "Feeder Range", "2 - Feeding", "Trough Range");
			Set("27 - Companions", "Feeder Recipe", "3 - Troughs", "Feed Barrel Recipe");
			Same("28 - Husbandry Experience", "10 - Experience", "Experience Multiplier|Taming Experience|Tamed Experience|Discovery Multiplier|Feeding Experience|Birth Experience|Petting Experience|Butchering Experience|Honey Experience");
			return map;
			void Same(string section, string target, string names)
			{
				string[] array = names.Split('|');
				foreach (string text in array)
				{
					Set(section, text, target, text);
				}
			}
			void Set(string section, string key, string targetSection, string targetKey)
			{
				map[section + "." + key] = targetSection + "." + targetKey;
			}
		}

		public static ImportPlan Plan(ImportSource source, string text)
		{
			ImportPlan importPlan = new ImportPlan(source);
			if (source == ImportSource.EliteCreaturesReborn)
			{
				foreach (KeyValuePair<string, string> item in SimpleYaml.Read(text))
				{
					if (item.Key == "breeding.enabled")
					{
						if (!bool.TryParse(item.Value, out var result))
						{
							throw new ArgumentException("Invalid breeding.enabled.");
						}
						if (result)
						{
							importPlan.Values["6 - Breeding.Star Inheritance"] = "BestParentUniform";
						}
						else
						{
							importPlan.Notes.Add("Skip breeding.enabled=false: source inheritance is disabled.");
						}
					}
					else if (item.Key == "breeding.mutation chance")
					{
						importPlan.Values["6 - Breeding.Mutation Chance"] = item.Value;
					}
					else
					{
						importPlan.Notes.Add("Skip " + item.Key + ": outside Shepherd mappings.");
					}
				}
				return importPlan;
			}
			foreach (SourceEntry item2 in SourceConfig.Parse(text))
			{
				string text2 = item2.Section + "." + item2.Key;
				if (((source == ImportSource.AutoFeedRedux) ? (item2.Section == "Synced Settings") : (item2.Section != "Synced Settings")) && mappings.TryGetValue(text2, out string value))
				{
					importPlan.Values[value] = item2.Value;
				}
				else
				{
					importPlan.Notes.Add("Skip " + text2 + ": outside Shepherd mappings.");
				}
			}
			return importPlan;
		}
	}
	public sealed class SourceModuleDecision
	{
		public bool Feeding { get; internal set; }

		public bool Husbandry { get; internal set; }

		public bool Inheritance { get; internal set; }

		public bool Containers { get; internal set; }
	}
	public static class SourceModules
	{
		public const string AutoFeedRedux = "vapok.mods.AutoFeedRedux";

		public const string GrindstoneSkills = "com.GrindstoneSkills";

		public const string EliteCreaturesReborn = "gglasgow.elitecreaturesreborn";

		public const string OpenKeep = "milkyteam.openkeep";

		public static SourceModuleDecision Decide(IEnumerable<string> installed, bool? gsHusbandry, bool? ecrBreeding, bool? openKeepPets)
		{
			HashSet<string> hashSet = new HashSet<string>(installed, StringComparer.Ordinal);
			bool flag = hashSet.Contains("com.GrindstoneSkills") && gsHusbandry != false;
			return new SourceModuleDecision
			{
				Feeding = (hashSet.Contains("vapok.mods.AutoFeedRedux") || flag),
				Husbandry = flag,
				Inheritance = (hashSet.Contains("gglasgow.elitecreaturesreborn") && ecrBreeding != false),
				Containers = (hashSet.Contains("milkyteam.openkeep") && openKeepPets != false)
			};
		}
	}
}
namespace ExtraPotions.Shepherd.Breeding
{
	public sealed class BirthInput
	{
		public string Token { get; }

		public LineageRecord? Mother { get; }

		public string MotherName { get; }

		public int MotherLevel { get; }

		public SireRecord? Sire { get; }

		public int MinOffspringLevel { get; }

		public double KeeperLevel { get; }

		public int Day { get; }

		public string Breeder { get; }

		public bool RecordLineage { get; }

		public string Traits { get; }

		public BirthInput(string token, LineageRecord? mother, string motherName, int motherLevel, SireRecord? sire, int minOffspringLevel, double keeperLevel, int day, string breeder, bool recordLineage, string traits)
		{
			Token = token ?? "";
			Mother = mother;
			MotherName = motherName ?? "";
			MotherLevel = motherLevel;
			Sire = sire;
			MinOffspringLevel = minOffspringLevel;
			KeeperLevel = keeperLevel;
			Day = day;
			Breeder = breeder ?? "";
			RecordLineage = recordLineage;
			Traits = traits ?? "";
		}
	}
	public sealed class BirthPlan
	{
		public InheritanceResult Inheritance { get; }

		public int Level => Inheritance.Level;

		public LineageRecord? Lineage { get; }

		public EggRecord Egg { get; }

		public int EggQuality => Inheritance.Level;

		public BirthPlan(InheritanceResult inheritance, LineageRecord? lineage, EggRecord egg)
		{
			Inheritance = inheritance;
			Lineage = lineage;
			Egg = egg;
		}
	}
	public static class BirthPlanner
	{
		public static BirthPlan Plan(BirthInput input, InheritanceSettings settings, IBreedingRandom random)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			InheritanceResult inheritance = StarInheritance.Compute(new InheritanceInput(input.MotherLevel, input.Sire?.Level ?? 0, input.MinOffspringLevel, input.KeeperLevel), settings, random);
			LineageRecord lineageRecord = (input.RecordLineage ? Lineage.Newborn(input.Token, input.Mother, input.MotherName, input.Sire, input.Day, input.Breeder) : null);
			EggRecord egg = ((lineageRecord != null) ? EggRecord.FromNewborn(lineageRecord, input.Traits) : new EggRecord("", "", "", "", 0, 0, "", input.Traits));
			return new BirthPlan(inheritance, lineageRecord, egg);
		}
	}
	public enum BreedingVerb : byte
	{
		Help,
		Breed,
		Stars
	}
	public readonly struct BreedingCommandLine
	{
		public BreedingVerb Verb { get; }

		public int Level { get; }

		private BreedingCommandLine(BreedingVerb verb, int level = 0)
		{
			Verb = verb;
			Level = level;
		}

		public static BreedingCommandLine Parse(IReadOnlyList<string> args, int maxLevel)
		{
			if (args.Count == 1 && args[0].Equals("breed", StringComparison.OrdinalIgnoreCase))
			{
				return new BreedingCommandLine(BreedingVerb.Breed);
			}
			if (args.Count == 2 && args[0].Equals("stars", StringComparison.OrdinalIgnoreCase) && int.TryParse(args[1], NumberStyles.None, CultureInfo.InvariantCulture, out var result) && result < maxLevel)
			{
				return new BreedingCommandLine(BreedingVerb.Stars, result + 1);
			}
			return new BreedingCommandLine(BreedingVerb.Help);
		}
	}
	public readonly struct PaceFields : IEquatable<PaceFields>
	{
		public double PregnancyDuration { get; }

		public double PregnancyChance { get; }

		public int MaxCreatures { get; }

		public PaceFields(double pregnancyDuration, double pregnancyChance, int maxCreatures)
		{
			PregnancyDuration = pregnancyDuration;
			PregnancyChance = pregnancyChance;
			MaxCreatures = maxCreatures;
		}

		public bool Equals(PaceFields other)
		{
			if (PregnancyDuration.Equals(other.PregnancyDuration) && PregnancyChance.Equals(other.PregnancyChance))
			{
				return MaxCreatures == other.MaxCreatures;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((PregnancyDuration.GetHashCode() * 397) ^ PregnancyChance.GetHashCode()) * 397) ^ MaxCreatures;
		}

		public override string ToString()
		{
			return PregnancyDuration + "/" + PregnancyChance + "/" + MaxCreatures;
		}
	}
	public sealed class PacedCall
	{
		public bool Paced { get; }

		public PaceFields Fields { get; }

		public PaceFields Original { get; }

		public PacedCall(bool paced, PaceFields fields, PaceFields original)
		{
			Paced = paced;
			Fields = fields;
			Original = original;
		}
	}
	public static class BreedingPace
	{
		public static double SpeedFactor(double breedingSpeedAt100, double keeperLevel, bool content, double contentBonusPercent)
		{
			double num = 1.0 + HusbandryShare.Share(breedingSpeedAt100, keeperLevel);
			if (content)
			{
				num += Math.Max(0.0, contentBonusPercent) / 100.0;
			}
			return num;
		}

		public static PacedCall Apply(PaceFields original, double factor, int room)
		{
			if (!(factor > 1.0) && room <= 0)
			{
				return new PacedCall(paced: false, original, original);
			}
			double num = Math.Max(1.0, factor);
			int maxCreatures = ((room > 0 && original.MaxCreatures > int.MaxValue - room) ? int.MaxValue : (original.MaxCreatures + Math.Max(0, room)));
			return new PacedCall(paced: true, new PaceFields(original.PregnancyDuration / num, original.PregnancyChance / num, maxCreatures), original);
		}

		public static double GrowthFactor(double growthSpeedAt100, double keeperLevel)
		{
			return 1.0 + HusbandryShare.Share(growthSpeedAt100, keeperLevel);
		}

		public static double ScaledTime(double time, double factor)
		{
			if (!(factor > 1.0))
			{
				return time;
			}
			return time / factor;
		}

		public static double TwinStartOffset(double pregnancyDuration, double twinDelay)
		{
			return 0.0 - Math.Max(0.0, pregnancyDuration - twinDelay);
		}
	}
	public interface IBreedingRandom
	{
		double Value();

		int Range(int minInclusive, int maxExclusive);
	}
	public sealed class SeededRandom : IBreedingRandom
	{
		private readonly Random random;

		public SeededRandom(int seed)
		{
			random = new Random(seed);
		}

		public double Value()
		{
			return random.NextDouble();
		}

		public int Range(int minInclusive, int maxExclusive)
		{
			return random.Next(minInclusive, maxExclusive);
		}
	}
	public interface IKeyStore
	{
		string GetString(string key);

		int GetInt(string key);

		long GetLong(string key);

		bool GetBool(string key);

		void Set(string key, string value);

		void Set(string key, int value);

		void Set(string key, long value);

		void Set(string key, bool value);
	}
	public static class BreedingKeys
	{
		public const string Instance = "shepherd.instance";

		public const string Mother = "shepherd.mother";

		public const string Sire = "shepherd.sire";

		public const string MotherName = "shepherd.mother_name";

		public const string SireName = "shepherd.sire_name";

		public const string Generation = "shepherd.gen";

		public const string Born = "shepherd.born";

		public const string Breeder = "shepherd.breeder";

		public const string PendingSire = "shepherd.pending_sire";

		public const string PendingSireName = "shepherd.pending_sire_name";

		public const string PendingSireLevel = "shepherd.pending_sire_level";

		public const string PendingSireGeneration = "shepherd.pending_sire_gen";

		public const string PendingSireTraits = "shepherd.pending_sire_traits";

		public const string TwinDue = "shepherd.twin_due";

		public const string IsTwin = "shepherd.is_twin";

		public const string ContentUntil = "shepherd.content_until";

		public const string ProduceNext = "shepherd.produce_next";

		public const string Traits = "shepherd.traits";

		public const string Births = "shepherd.births";

		public const string Egg = "shepherd.egg";

		private static readonly string[] Keys = new string[20]
		{
			"shepherd.instance", "shepherd.mother", "shepherd.sire", "shepherd.mother_name", "shepherd.sire_name", "shepherd.gen", "shepherd.born", "shepherd.breeder", "shepherd.pending_sire", "shepherd.pending_sire_name",
			"shepherd.pending_sire_level", "shepherd.pending_sire_gen", "shepherd.pending_sire_traits", "shepherd.twin_due", "shepherd.is_twin", "shepherd.content_until", "shepherd.produce_next", "shepherd.traits", "shepherd.births", "shepherd.egg"
		};

		public static IReadOnlyList<string> All => Keys;
	}
	public static class BreedingStore
	{
		public static void WriteLineage(IKeyStore store, LineageRecord record)
		{
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			if (record == null)
			{
				throw new ArgumentNullException("record");
			}
			store.Set("shepherd.instance", record.Token);
			store.Set("shepherd.mother", record.MotherToken);
			store.Set("shepherd.sire", record.SireToken);
			store.Set("shepherd.mother_name", record.MotherName);
			store.Set("shepherd.sire_name", record.SireName);
			store.Set("shepherd.gen", record.Generation);
			store.Set("shepherd.born", record.BornDay);
			store.Set("shepherd.breeder", record.Breeder);
		}

		public static LineageRecord? ReadLineage(IKeyStore store)
		{
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			string text = store.GetString("shepherd.instance");
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			return new LineageRecord(text, store.GetString("shepherd.mother"), store.GetString("shepherd.sire"), store.GetString("shepherd.mother_name"), store.GetString("shepherd.sire_name"), Math.Max(0, store.GetInt("shepherd.gen")), store.GetInt("shepherd.born"), store.GetString("shepherd.breeder"));
		}

		public static void WritePendingSire(IKeyStore store, SireRecord? sire)
		{
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			store.Set("shepherd.pending_sire", sire?.Token ?? "");
			store.Set("shepherd.pending_sire_name", sire?.Name ?? "");
			store.Set("shepherd.pending_sire_level", sire?.Level ?? 0);
			store.Set("shepherd.pending_sire_gen", sire?.Generation ?? 0);
			store.Set("shepherd.pending_sire_traits", sire?.Traits ?? "");
		}

		public static SireRecord? ReadPendingSire(IKeyStore store)
		{
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			int num = store.GetInt("shepherd.pending_sire_level");
			if (num < 1)
			{
				return null;
			}
			return new SireRecord(store.GetString("shepherd.pending_sire"), store.GetString("shepherd.pending_sire_name"), num, store.GetInt("shepherd.pending_sire_gen"), store.GetString("shepherd.pending_sire_traits"));
		}

		public static void SetTwinDue(IKeyStore store, double worldSeconds)
		{
			SetTime(store, "shepherd.twin_due", worldSeconds);
		}

		public static double GetTwinDue(IKeyStore store)
		{
			return GetTime(store, "shepherd.twin_due");
		}

		public static void SetContentUntil(IKeyStore store, double worldSeconds)
		{
			SetTime(store, "shepherd.content_until", worldSeconds);
		}

		public static double GetContentUntil(IKeyStore store)
		{
			return GetTime(store, "shepherd.content_until");
		}

		public static void SetProduceNext(IKeyStore store, double worldSeconds)
		{
			SetTime(store, "shepherd.produce_next", worldSeconds);
		}

		public static double GetProduceNext(IKeyStore store)
		{
			return GetTime(store, "shepherd.produce_next");
		}

		public static bool IsTwin(IKeyStore store)
		{
			return (store ?? throw new ArgumentNullException("store")).GetBool("shepherd.is_twin");
		}

		public static void SetIsTwin(IKeyStore store, bool value)
		{
			(store ?? throw new ArgumentNullException("store")).Set("shepherd.is_twin", value);
		}

		public static string GetTraits(IKeyStore store)
		{
			return (store ?? throw new ArgumentNullException("store")).GetString("shepherd.traits");
		}

		public static void SetTraits(IKeyStore store, string traits)
		{
			(store ?? throw new ArgumentNullException("store")).Set("shepherd.traits", traits ?? "");
		}

		private static void SetTime(IKeyStore store, string key, double worldSeconds)
		{
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			bool flag = !double.IsNaN(worldSeconds) && !double.IsInfinity(worldSeconds) && worldSeconds > 0.0 && worldSeconds < 9223372036854776.0;
			store.Set(key, flag ? ((long)Math.Round(worldSeconds * 1000.0)) : 0);
		}

		private static double GetTime(IKeyStore store, string key)
		{
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			return (double)Math.Max(0L, store.GetLong(key)) / 1000.0;
		}
	}
	public sealed class ClaimSlot<T> where T : class
	{
		private T? record;

		private string? prefab;

		public bool Armed => record != null;

		public void Arm(T value, string offspringPrefab)
		{
			record = value ?? throw new ArgumentNullException("value");
			prefab = offspringPrefab ?? throw new ArgumentNullException("offspringPrefab");
		}

		public bool Claims(string? objectPrefab)
		{
			if (record != null && objectPrefab != null)
			{
				return objectPrefab == prefab;
			}
			return false;
		}

		public T? Claim(string? objectPrefab)
		{
			if (!Claims(objectPrefab))
			{
				return null;
			}
			T? result = record;
			Clear();
			return result;
		}

		public void Clear()
		{
			record = null;
			prefab = null;
		}
	}
	public static class Carry
	{
		public static bool GrowsNow(double secondsSinceSpawn, double growTime)
		{
			return secondsSinceSpawn > growTime;
		}

		public static LineageRecord GrowUp(LineageRecord young)
		{
			return Lineage.GrowUp(young);
		}

		public static LineageRecord? Hatch(string? eggText, string token)
		{
			if (!EggCodec.TryDecode(eggText, out EggRecord egg) || egg == null)
			{
				return null;
			}
			return Lineage.Hatch(egg, token);
		}
	}
	public sealed class EcrSire
	{
		public int Level { get; }

		public int Mask { get; }

		internal EcrSire(int level, int mask)
		{
			Level = level;
			Mask = mask;
		}
	}
	public readonly struct EcrEgg
	{
		public int Stars { get; }

		public int Level => Stars + 1;

		public int Mask { get; }

		public int Biome { get; }

		public EcrEgg(int stars, int mask, int biome)
		{
			Stars = stars;
			Mask = mask;
			Biome = biome;
		}
	}
	public static class EcrImport
	{
		public const string SireStarsKey = "ecr_sire_stars";

		public const string SireMaskKey = "ecr_sire_mask";

		public const string EggKey = "ecr_egg";

		public const string SireImportedKey = "shepherd.imported.ecr_sire";

		public const string StarUpKey = "grindstone_star_up";

		public static EcrSire? ReadSire(int sireStarsValue, int mask)
		{
			if (sireStarsValue > 0)
			{
				return new EcrSire(sireStarsValue, Math.Max(0, mask));
			}
			return null;
		}

		public static bool ImportPendingSire(IKeyStore store, out int mask)
		{
			if (store == null)
			{
				throw new ArgumentNullException("store");
			}
			mask = 0;
			EcrSire ecrSire = ReadSire(store.GetInt("ecr_sire_stars"), store.GetInt("ecr_sire_mask"));
			if (ecrSire == null || store.GetInt("shepherd.imported.ecr_sire") != 0 || BreedingStore.ReadPendingSire(store) != null)
			{
				return false;
			}
			BreedingStore.WritePendingSire(store, new SireRecord("", "", ecrSire.Level, 0, ""));
			store.Set("shepherd.imported.ecr_sire", 1);
			mask = ecrSire.Mask;
			return true;
		}

		public static bool TryParseEgg(string? text, out EcrEgg egg)
		{
			egg = default(EcrEgg);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			string[] array = text.Split(',');
			if (array.Length < 3 || !Int(array[0], out var value) || value == int.MaxValue || !Int(array[1], out var value2) || !Int(array[2], out var value3))
			{
				return false;
			}
			egg = new EcrEgg(value, value2, value3);
			return true;
		}

		private static bool Int(string text, out int value)
		{
			if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out value))
			{
				return value >= 0;
			}
			return false;
		}
	}
	public static class EggCodec
	{
		public const int MaxLength = 1024;

		public const int TrimmedNameLength = 64;

		private const string Version = "v1";

		private const int FieldCount = 9;

		public static string Encode(EggRecord egg)
		{
			if (egg == null)
			{
				throw new ArgumentNullException("egg");
			}
			string text = Join(egg, egg.Traits, int.MaxValue);
			if (text.Length > 1024)
			{
				text = Join(egg, "", int.MaxValue);
			}
			if (text.Length > 1024)
			{
				text = Join(egg, "", 64);
			}
			if (text.Length > 1024)
			{
				throw new ArgumentException("The egg's parent tokens do not fit in " + 1024 + " characters.", "egg");
			}
			return text;
		}

		public static bool TryDecode(string? text, out EggRecord? egg)
		{
			egg = null;
			if (string.IsNullOrEmpty(text) || text.Length > 1024)
			{
				return false;
			}
			List<string> list = Split(text);
			if (list == null || list.Count != 9 || list[0] != "v1")
			{
				return false;
			}
			if (!NonNegative(list[5], out var value) || !NonNegative(list[6], out var value2))
			{
				return false;
			}
			egg = new EggRecord(list[1], list[2], list[3], list[4], value, value2, list[7], list[8]);
			return true;
		}

		private static string Join(EggRecord egg, string traits, int nameLength)
		{
			StringBuilder stringBuilder = new StringBuilder("v1");
			string[] array = new string[8]
			{
				egg.MotherToken,
				egg.SireToken,
				Trim(egg.MotherName, nameLength),
				Trim(egg.SireName, nameLength),
				egg.Generation.ToString(CultureInfo.InvariantCulture),
				egg.BornDay.ToString(CultureInfo.InvariantCulture),
				Trim(egg.Breeder, nameLength),
				traits
			};
			foreach (string obj in array)
			{
				stringBuilder.Append(';');
				string text = obj;
				foreach (char c in text)
				{
					if (c == '\\' || c == ';')
					{
						stringBuilder.Append('\\');
					}
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		private static string Trim(string text, int length)
		{
			if (text.Length > length)
			{
				return text.Substring(0, length);
			}
			return text;
		}

		private static List<string>? Split(string text)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				switch (c)
				{
				case '\\':
					if (i + 1 >= text.Length || (text[i + 1] != '\\' && text[i + 1] != ';'))
					{
						return null;
					}
					stringBuilder.Append(text[++i]);
					break;
				case ';':
					list.Add(stringBuilder.ToString());
					stringBuilder.Clear();
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			list.Add(stringBuilder.ToString());
			return list;
		}

		private static bool NonNegative(string text, out int value)
		{
			return int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out value);
		}
	}
	public readonly struct HerdInput
	{
		public int VanillaMax { get; }

		public int Count { get; }

		public double HerdSizeAt100 { get; }

		public double KeeperLevel { get; }

		public bool Unlimited { get; }

		public bool Strict { get; }

		public HerdInput(int vanillaMax, int count, double herdSizeAt100, double keeperLevel, bool unlimited, bool strict)
		{
			VanillaMax = Math.Max(0, vanillaMax);
			Count = Math.Max(0, count);
			HerdSizeAt100 = herdSizeAt100;
			KeeperLevel = keeperLevel;
			Unlimited = unlimited;
			Strict = strict;
		}
	}
	public sealed class HerdVerdict
	{
		public int Bonus { get; }

		public int Limit { get; }

		public bool Unlimited { get; }

		public bool CanConceive { get; }

		public bool BirthMayProceed { get; }

		public bool WaitingForRoom => !BirthMayProceed;

		public int Room { get; }

		public int ExtraMax
		{
			get
			{
				if (!Unlimited)
				{
					return Bonus;
				}
				return int.MaxValue;
			}
		}

		internal HerdVerdict(int bonus, int limit, int count, bool unlimited, bool strict)
		{
			Bonus = bonus;
			Limit = limit;
			Unlimited = unlimited;
			CanConceive = unlimited || count < limit;
			BirthMayProceed = unlimited || !strict || count < limit;
			Room = (unlimited ? int.MaxValue : Math.Max(0, limit - count));
		}
	}
	public readonly struct HerdLine
	{
		public string Key { get; }

		public int Room { get; }

		public int Limit { get; }

		public HerdLine(string key, int room, int limit)
		{
			Key = key;
			Room = room;
			Limit = limit;
		}
	}
	public static class HerdLimit
	{
		public static HerdVerdict Evaluate(HerdInput input)
		{
			int num = HusbandryShare.ExtraRoom(input.HerdSizeAt100, input.KeeperLevel);
			int limit = (int)(input.Unlimited ? int.MaxValue : Math.Min(2147483646L, (long)input.VanillaMax + (long)num));
			return new HerdVerdict(num, limit, input.Count, input.Unlimited, input.Strict);
		}

		public static bool HoldsBirth(HerdVerdict verdict, bool pregnant, bool due)
		{
			if (verdict != null && pregnant && due)
			{
				return !verdict.BirthMayProceed;
			}
			return false;
		}

		public static HerdLine Describe(HerdVerdict verdict, bool pregnant, bool due)
		{
			if (verdict == null)
			{
				throw new ArgumentNullException("verdict");
			}
			if (HoldsBirth(verdict, pregnant, due))
			{
				return new HerdLine("herd_waiting", 0, verdict.Limit);
			}
			if (verdict.Unlimited)
			{
				return new HerdLine("herd_unlimited", 0, 0);
			}
			return new HerdLine("herd_room", verdict.Room, verdict.Limit);
		}
	}
	public static class HusbandryShare
	{
		public const double MaxLevel = 100.0;

		public static double Share(double percentAt100, double level)
		{
			return Math.Max(0.0, percentAt100) / 100.0 * Clamp01(level / 100.0);
		}

		public static bool Rolls(double percentAt100, double level, IBreedingRandom random)
		{
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			double num = Share(percentAt100, level);
			if (num > 0.0)
			{
				return random.Value() < num;
			}
			return false;
		}

		public static bool RollsFlat(double percent, IBreedingRandom random)
		{
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			double num = Math.Max(0.0, percent) / 100.0;
			if (num > 0.0)
			{
				return random.Value() < num;
			}
			return false;
		}

		public static int ExtraRoom(double herdSizeAt100, double level)
		{
			return (int)Math.Floor(Math.Max(0.0, herdSizeAt100) * Clamp01(level / 100.0) + 0.5);
		}

		private static double Clamp01(double value)
		{
			if (!double.IsNaN(value))
			{
				return Math.Min(1.0, Math.Max(0.0, value));
			}
			return 0.0;
		}
	}
	public sealed class LineageRecord
	{
		public string Token { get; }

		public string MotherToken { get; }

		public string SireToken { get; }

		public string MotherName { get; }

		public string SireName { get; }

		public int Generation { get; }

		public int BornDay { get; }

		public string Breeder { get; }

		public LineageRecord(string token, string motherToken, string sireToken, string motherName, string sireName, int generation, int bornDay, string breeder)
		{
			if (generation < 0)
			{
				throw new ArgumentOutOfRangeException("generation");
			}
			Token = token ?? "";
			MotherToken = motherToken ?? "";
			SireToken = sireToken ?? "";
			MotherName = motherName ?? "";
			SireName = sireName ?? "";
			Generation = generation;
			BornDay = Math.Max(0, bornDay);
			Breeder = breeder ?? "";
		}

		public LineageRecord WithToken(string token)
		{
			return new LineageRecord(token, MotherToken, SireToken, MotherName, SireName, Generation, BornDay, Breeder);
		}
	}
	public static class Lineage
	{
		public static LineageRecord Wild(string token)
		{
			return new LineageRecord(token, "", "", "", "", 0, 0, "");
		}

		public static LineageRecord Newborn(string token, LineageRecord? mother, string motherName, SireRecord? sire, int day, string breeder)
		{
			int generation = Math.Max(mother?.Generation ?? 0, sire?.Generation ?? 0) + 1;
			return new LineageRecord(token, mother?.Token ?? "", sire?.Token ?? "", motherName ?? "", sire?.Name ?? "", generation, day, breeder ?? "");
		}

		public static LineageRecord GrowUp(LineageRecord young)
		{
			if (young == null)
			{
				throw new ArgumentNullException("young");
			}
			return young.WithToken(young.Token);
		}

		public static LineageRecord Hatch(EggRecord egg, string token)
		{
			if (egg == null)
			{
				throw new ArgumentNullException("egg");
			}
			return new LineageRecord(token, egg.MotherToken, egg.SireToken, egg.MotherName, egg.SireName, egg.Generation, egg.BornDay, egg.Breeder);
		}
	}
	public sealed class EggRecord
	{
		public string MotherToken { get; }

		public string SireToken { get; }

		public string MotherName { get; }

		public string SireName { get; }

		public int Generation { get; }

		public int BornDay { get; }

		public string Breeder { get; }

		public string Traits { get; }

		public EggRecord(string motherToken, string sireToken, string motherName, string sireName, int generation, int bornDay, string breeder, string traits)
		{
			if (generation < 0)
			{
				throw new ArgumentOutOfRangeException("generation");
			}
			if (bornDay < 0)
			{
				throw new ArgumentOutOfRangeException("bornDay");
			}
			MotherToken = motherToken ?? "";
			SireToken = sireToken ?? "";
			MotherName = motherName ?? "";
			SireName = sireName ?? "";
			Generation = generation;
			BornDay = bornDay;
			Breeder = breeder ?? "";
			Traits = traits ?? "";
		}

		public static EggRecord FromNewborn(LineageRecord newborn, string traits)
		{
			if (newborn == null)
			{
				throw new ArgumentNullException("newborn");
			}
			return new EggRecord(newborn.MotherToken, newborn.SireToken, newborn.MotherName, newborn.SireName, newborn.Generation, newborn.BornDay, newborn.Breeder, traits);
		}
	}
	public readonly struct SeasonBreedRate
	{
		public bool Active { get; }

		public float Rate { get; }

		public bool Stop { get; }

		public SeasonBreedRate(bool active, float rate)
		{
			if (!active || float.IsNaN(rate) || float.IsInfinity(rate) || rate < 0f)
			{
				Active = false;
				Rate = 1f;
				Stop = false;
				return;
			}
			Active = true;
			Stop = rate <= 0f;
			if (Stop)
			{
				Rate = 0f;
			}
			else if (rate < 0.25f)
			{
				Rate = 0.25f;
			}
			else if (rate > 3f)
			{
				Rate = 3f;
			}
			else
			{
				Rate = rate;
			}
		}
	}
	public readonly struct SeasonEdit
	{
		public bool Changed { get; }

		public bool Stop { get; }

		public double Duration { get; }

		public double Chance { get; }

		public double PartnerRange { get; }

		public double TotalRange { get; }

		public SeasonEdit(bool changed, bool stop, double duration, double chance, double partnerRange, double totalRange)
		{
			Changed = changed;
			Stop = stop;
			Duration = duration;
			Chance = chance;
			PartnerRange = partnerRange;
			TotalRange = totalRange;
		}
	}
	public static class SeasonBreeding
	{
		public const string Id = "meadworks.seasons.facts";

		public static readonly Version Version = new Version(1, 0);

		public const float MinRate = 0.25f;

		public const float MaxRate = 3f;

		public const int MaxLength = 8192;

		public static SeasonBreedRate Read(Func<string>? provider)
		{
			try
			{
				SeasonBreedRate rate;
				return (provider != null && TryParse(provider(), out rate)) ? rate : default(SeasonBreedRate);
			}
			catch (Exception)
			{
				return default(SeasonBreedRate);
			}
		}

		public static bool TryParse(string? text, out SeasonBreedRate rate)
		{
			rate = default(SeasonBreedRate);
			if (!Fields(text, out Dictionary<string, string> fields) || !Ready(fields) || !Number(fields, "breed", out var value) || value < 0f)
			{
				return false;
			}
			rate = new SeasonBreedRate(active: true, value);
			return rate.Active;
		}

		public static SeasonEdit Edit(double duration, double chance, double partner, double total, SeasonBreedRate rate)
		{
			if (!rate.Active || rate.Rate == 1f)
			{
				return new SeasonEdit(changed: false, stop: false, duration, chance, partner, total);
			}
			if (rate.Stop)
			{
				return new SeasonEdit(changed: true, stop: true, duration, 1.0, partner, total);
			}
			double duration2 = ((duration > 0.0) ? Math.Max(1.0, duration / (double)rate.Rate) : duration);
			double num = (1.0 - chance) * (double)rate.Rate;
			if (num < 0.0)
			{
				num = 0.0;
			}
			else if (num > 1.0)
			{
				num = 1.0;
			}
			double partnerRange = partner * (double)rate.Rate;
			double totalRange = ((total > 0.0) ? Math.Max(0.5, total / (double)rate.Rate) : total);
			return new SeasonEdit(changed: true, stop: false, duration2, 1.0 - num, partnerRange, totalRange);
		}

		public static string Prefix(long worldId, string sessionId)
		{
			return "1|" + worldId.ToString(CultureInfo.InvariantCulture) + "|" + Convert.ToBase64String(Encoding.UTF8.GetBytes(sessionId ?? "")) + "|";
		}

		public static string Wrap(long worldId, string sessionId, string? facts)
		{
			return Prefix(worldId, sessionId) + facts;
		}

		public static bool TryUnwrap(string? carrier, long worldId, string sessionId, out string facts)
		{
			facts = "";
			if (string.IsNullOrEmpty(carrier))
			{
				return false;
			}
			string text = Prefix(worldId, sessionId);
			if (!carrier.StartsWith(text, StringComparison.Ordinal))
			{
				return false;
			}
			facts = carrier.Substring(text.Length);
			return true;
		}

		private static bool Ready(Dictionary<string, string> fields)
		{
			if (!Integer(fields, "effects", out var value) || value != 1)
			{
				return false;
			}
			if (!Integer(fields, "season", out var value2) || value2 < 0 || value2 > 3)
			{
				return false;
			}
			if (Integer(fields, "day", out var value3) && Integer(fields, "length", out var value4) && value4 >= 1 && value3 >= 0)
			{
				return value3 <= value4;
			}
			return false;
		}

		private static bool Fields(string? text, out Dictionary<string, string> fields)
		{
			fields = new Dictionary<string, string>(StringComparer.Ordinal);
			if (string.IsNullOrEmpty(text) || text.Length > 8192)
			{
				return false;
			}
			string[] array = text.Split(';');
			foreach (string text2 in array)
			{
				int num = text2.IndexOf('=');
				if (num <= 0)
				{
					continue;
				}
				string text3 = text2.Substring(0, num);
				if (!(text3 != "effects") || !(text3 != "season") || !(text3 != "day") || !(text3 != "length") || !(text3 != "breed"))
				{
					if (fields.ContainsKey(text3))
					{
						return false;
					}
					fields.Add(text3, text2.Substring(num + 1));
				}
			}
			return true;
		}

		private static bool Integer(Dictionary<string, string> fields, string key, out int value)
		{
			value = 0;
			if (fields.TryGetValue(key, out string value2))
			{
				return int.TryParse(value2, NumberStyles.Integer, CultureInfo.InvariantCulture, out value);
			}
			return false;
		}

		private static bool Number(Dictionary<string, string> fields, string key, out float value)
		{
			value = 0f;
			if (fields.TryGetValue(key, out string value2) && float.TryParse(value2, NumberStyles.Float, CultureInfo.InvariantCulture, out value) && !float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public sealed class PartnerCandidate
	{
		public string Token { get; }

		public string Name { get; }

		public string PrefabName { get; }

		public int Level { get; }

		public int Generation { get; }

		public string Traits { get; }

		public double Distance { get; }

		public bool IsSelf { get; }

		public bool IsTamed { get; }

		public bool IsReady { get; }

		public PartnerCandidate(string token, string name, string prefabName, int level, int generation, string traits, double distance, bool isSelf, bool isTamed, bool isReady)
		{
			Token = token ?? "";
			Name = name ?? "";
			PrefabName = prefabName ?? "";
			Level = level;
			Generation = generation;
			Traits = traits ?? "";
			Distance = distance;
			IsSelf = isSelf;
			IsTamed = isTamed;
			IsReady = isReady;
		}
	}
	public sealed class SireRecord
	{
		public string Token { get; }

		public string Name { get; }

		public int Level { get; }

		public int Generation { get; }

		public string Traits { get; }

		public SireRecord(string token, string name, int level, int generation, string traits)
		{
			if (level < 1)
			{
				throw new ArgumentOutOfRangeException("level", "levels start at 1");
			}
			Token = token ?? "";
			Name = name ?? "";
			Level = level;
			Generation = Math.Max(0, generation);
			Traits = traits ?? "";
		}
	}
	public static class SireCapture
	{
		public static SireRecord? Choose(string partnerPrefab, double partnerRange, IEnumerable<PartnerCandidate> candidates)
		{
			if (candidates == null)
			{
				throw new ArgumentNullException("candidates");
			}
			if (string.IsNullOrEmpty(partnerPrefab))
			{
				return null;
			}
			PartnerCandidate partnerCandidate = null;
			foreach (PartnerCandidate candidate in candidates)
			{
				if (candidate != null && !candidate.IsSelf && candidate.IsTamed && candidate.IsReady && string.Equals(candidate.PrefabName, partnerPrefab, StringComparison.Ordinal) && candidate.Distance <= partnerRange && (partnerCandidate == null || candidate.Distance < partnerCandidate.Distance))
				{
					partnerCandidate = candidate;
				}
			}
			if (partnerCandidate != null)
			{
				return new SireRecord(partnerCandidate.Token, partnerCandidate.Name, Math.Max(1, partnerCandidate.Level), partnerCandidate.Generation, partnerCandidate.Traits);
			}
			return null;
		}
	}
	public enum InheritanceMode
	{
		Vanilla,
		BestParentUniform,
		ParentMean
	}
	public sealed class InheritanceSettings
	{
		public static InheritanceSettings Default { get; } = new InheritanceSettings(InheritanceMode.ParentMean, 1, 3, 25.0, 0.0);

		public InheritanceMode Mode { get; }

		public int MaxAboveBestParent { get; }

		public int MaxOffspringLevel { get; }

		public double BetterOffspringAt100 { get; }

		public double BirthStarChance { get; }

		public bool TamedStars { get; }

		public InheritanceSettings(InheritanceMode mode, int maxAboveBestParent, int maxOffspringLevel, double betterOffspringAt100, double birthStarChance, bool tamedStars = true)
		{
			if (!Enum.IsDefined(typeof(InheritanceMode), mode))
			{
				throw new ArgumentOutOfRangeException("mode");
			}
			if (maxAboveBestParent < 0 || maxAboveBestParent > 2)
			{
				throw new ArgumentOutOfRangeException("maxAboveBestParent", "0 to 2");
			}
			if (maxOffspringLevel < 1 || maxOffspringLevel > 10)
			{
				throw new ArgumentOutOfRangeException("maxOffspringLevel", "1 to 10");
			}
			if (!(betterOffspringAt100 >= 0.0) || !(betterOffspringAt100 <= 100.0))
			{
				throw new ArgumentOutOfRangeException("betterOffspringAt100", "0 to 100");
			}
			if (!(birthStarChance >= 0.0) || !(birthStarChance <= 100.0))
			{
				throw new ArgumentOutOfRangeException("birthStarChance", "0 to 100");
			}
			Mode = mode;
			MaxAboveBestParent = maxAboveBestParent;
			MaxOffspringLevel = maxOffspringLevel;
			BetterOffspringAt100 = betterOffspringAt100;
			BirthStarChance = birthStarChance;
			TamedStars = tamedStars;
		}
	}
	public readonly struct InheritanceInput
	{
		public int MotherLevel { get; }

		public int SireLevel { get; }

		public int MinOffspringLevel { get; }

		public double KeeperLevel { get; }

		public bool HasSire => SireLevel > 0;

		public InheritanceInput(int motherLevel, int sireLevel, int minOffspringLevel, double keeperLevel)
		{
			if (motherLevel < 1)
			{
				throw new ArgumentOutOfRangeException("motherLevel", "levels start at 1");
			}
			if (sireLevel < 0)
			{
				throw new ArgumentOutOfRangeException("sireLevel", "0 means no sire");
			}
			MotherLevel = motherLevel;
			SireLevel = sireLevel;
			MinOffspringLevel = Math.Max(0, minOffspringLevel);
			KeeperLevel = keeperLevel;
		}
	}
	public sealed class InheritanceResult
	{
		public int Base { get; }

		public int Best { get; }

		public int Cap { get; }

		public int Level { get; }

		public bool BetterOffspring { get; }

		public bool BirthStar { get; }

		public bool StrongOffspring => Level > Best;

		internal InheritanceResult(int @base, int best, int cap, int level, bool betterOffspring, bool birthStar)
		{
			Base = @base;
			Best = best;
			Cap = cap;
			Level = level;
			BetterOffspring = betterOffspring;
			BirthStar = birthStar;
		}
	}
	public static class StarInheritance
	{
		public static InheritanceResult Compute(InheritanceInput input, InheritanceSettings settings, IBreedingRandom random)
		{
			if (settings == null)
			{
				throw new ArgumentNullException("settings");
			}
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			int motherLevel = input.MotherLevel;
			int num = (input.HasSire ? input.SireLevel : motherLevel);
			if (!settings.TamedStars)
			{
				int num2 = Math.Max(1, motherLevel);
				return new InheritanceResult(num2, Math.Max(motherLevel, num), num2, num2, betterOffspring: false, birthStar: false);
			}
			int num3 = Math.Max(motherLevel, num);
			int val = Math.Max(1, input.MinOffspringLevel);
			int num4 = Math.Max(val, Math.Min(num3 + settings.MaxAboveBestParent, settings.MaxOffspringLevel));
			int num5 = Math.Max(val, BaseLevel(settings.Mode, motherLevel, num, num3, random));
			int num6 = num5;
			bool flag = HusbandryShare.Rolls(settings.BetterOffspringAt100, input.KeeperLevel, random) && num5 < num4;
			if (flag)
			{
				num5++;
			}
			bool flag2 = HusbandryShare.RollsFlat(settings.BirthStarChance, random) && num5 < num4;
			if (flag2)
			{
				num5++;
			}
			return new InheritanceResult(num6, num3, num4, num5, flag, flag2);
		}

		private static int BaseLevel(InheritanceMode mode, int mother, int sire, int best, IBreedingRandom random)
		{
			return mode switch
			{
				InheritanceMode.Vanilla => mother, 
				InheritanceMode.BestParentUniform => 1 + random.Range(0, best), 
				_ => (mother + sire + 1) / 2, 
			};
		}
	}
	public sealed class TraitsConsumer
	{
		public const string Id = "meadworks.creatures.traits";

		public static readonly Version Version = new Version(1, 0);

		private readonly Tuple<Func<object, string>, Func<string, string, int, float, int, string>, Action<object, string>, Func<string, string>, Func<string, string>>? provider;

		public bool Available => provider != null;

		public TraitsConsumer(Tuple<Func<object, string>, Func<string, string, int, float, int, string>, Action<object, string>, Func<string, string>, Func<string, string>>? provider)
		{
			this.provider = provider;
		}

		public string Read(object? target, string fallback = "")
		{
			if (target == null)
			{
				return fallback;
			}
			try
			{
				return provider?.Item1(target) ?? fallback;
			}
			catch (Exception)
			{
				return fallback;
			}
		}

		public BirthPlan Inherit(BirthPlan plan, string mother, string sire, int seed, float mutationChance = 100f)
		{
			float arg = (float.IsNaN(mutationChance) ? 0f : Math.Max(0f, Math.Min(100f, mutationChance)));
			string traits;
			try
			{
				traits = provider?.Item2(mother, sire, plan.Level, arg, seed) ?? "";
			}
			catch (Exception)
			{
				traits = "";
			}
			return new BirthPlan(plan.Inheritance, plan.Lineage, WithTraits(plan.Egg, traits));
		}

		public void Apply(object target, string traits)
		{
			try
			{
				provider?.Item3(target, traits);
			}
			catch (Exception)
			{
			}
		}

		public string EncodeEgg(EggRecord egg)
		{
			string traits;
			try
			{
				traits = provider?.Item4(egg.Traits) ?? egg.Traits;
			}
			catch (Exception)
			{
				traits = egg.Traits;
			}
			return EggCodec.Encode(WithTraits(egg, traits));
		}

		public OffspringCarry Hatch(EggRecord egg, string token)
		{
			string traits;
			try
			{
				traits = provider?.Item5(egg.Traits) ?? egg.Traits;
			}
			catch (Exception)
			{
				traits = egg.Traits;
			}
			return new OffspringCarry((egg.Generation != 0 || egg.BornDay != 0 || egg.MotherToken.Length != 0 || egg.SireToken.Length != 0 || egg.MotherName.Length != 0 || egg.SireName.Length != 0 || egg.Breeder.Length != 0) ? Lineage.Hatch(egg, token) : null, traits);
		}

		public string DecodeLegacyEgg(string text)
		{
			try
			{
				return provider?.Item5(text) ?? "";
			}
			catch (Exception)
			{
				return "";
			}
		}

		private static EggRecord WithTraits(EggRecord egg, string traits)
		{
			return new EggRecord(egg.MotherToken, egg.SireToken, egg.MotherName, egg.SireName, egg.Generation, egg.BornDay, egg.Breeder, traits);
		}
	}
	public sealed class OffspringCarry
	{
		public LineageRecord? Lineage { get; }

		public string Traits { get; }

		public OffspringCarry(LineageRecord? lineage, string traits)
		{
			Lineage = lineage;
			Traits = traits ?? "";
		}
	}
	public static class TwinRules
	{
		public const double DefaultDelaySeconds = 30.0;

		public const double MinDelaySeconds = 5.0;

		public const double MaxDelaySeconds = 300.0;

		public static bool RollTwin(bool birthWasTwin, double twinsAt100, double keeperLevel, IBreedingRandom random)
		{
			if (random == null)
			{
				throw new ArgumentNullException("random");
			}
			if (!birthWasTwin)
			{
				return HusbandryShare.Rolls(twinsAt100, keeperLevel, random);
			}
			return false;
		}

		public static double DueAt(double now, double delaySeconds)
		{
			double num = (double.IsNaN(delaySeconds) ? 30.0 : Math.Min(300.0, Math.Max(5.0, delaySeconds)));
			return now + num;
		}

		public static bool IsDue(double twinDue, double now)
		{
			if (twinDue > 0.0)
			{
				return now >= twinDue;
			}
			return false;
		}
	}
}