using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using ExtraPotions.Larder.Foods;
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.2.16.0")]
[assembly: AssemblyInformationalVersion("0.2.16")]
[assembly: AssemblyProduct("Larder.Core")]
[assembly: AssemblyTitle("Larder.Core")]
[assembly: AssemblyVersion("0.2.16.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.Larder
{
	public static class LarderCore
	{
		public const string ProductId = "com.meadworks.larder";

		public const string Name = "Larder";

		public const string Version = "0.2.16";

		public const string Family = "Hearth";

		public const string GameBuild = "1.0.17";

		public const string CharacterDataPrefix = "larder.";

		public const string ZdoPrefix = "larder_";

		public const string TokenPrefix = "$meadworks_larder_";
	}
	public static class LarderMath
	{
		public static float Clamp01(float value)
		{
			if (!(value < 0f))
			{
				if (!(value > 1f))
				{
					return value;
				}
				return 1f;
			}
			return 0f;
		}

		public static float Clamp(float value, float min, float max)
		{
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}

		public static float Lerp(float from, float to, float t)
		{
			return from + (to - from) * Clamp01(t);
		}

		public static float NonNegative(float value)
		{
			if (!(value > 0f) || float.IsInfinity(value))
			{
				return 0f;
			}
			return value;
		}

		public static bool Approximately(float a, float b)
		{
			return Math.Abs(b - a) < Math.Max(1E-06f * Math.Max(Math.Abs(a), Math.Abs(b)), 1.1E-44f);
		}
	}
}
namespace ExtraPotions.Larder.Recovery
{
	public static class EitrRegenRules
	{
		public static float HookMultiplier(float statusEffectMultiplier, float eitrVigorPercent, float curveFactor, bool blocking, float blockingFactor)
		{
			float num = statusEffectMultiplier + eitrVigorPercent / 100f;
			num *= curveFactor;
			if (blocking)
			{
				num *= blockingFactor / 0.8f;
			}
			return num;
		}
	}
	public static class FoodHealing
	{
		public const float TickSeconds = 10f;

		public static float PerFrame(float totalFoodRegen, float healthRegenMultiplier, float dt)
		{
			if (dt <= 0f || totalFoodRegen <= 0f)
			{
				return 0f;
			}
			return totalFoodRegen * healthRegenMultiplier * dt / 10f;
		}
	}
	public static class RegenCurve
	{
		public static float Factor(float fraction, float strength, float pivot)
		{
			if (strength <= 0f || LarderMath.Approximately(strength, 1f))
			{
				return 1f;
			}
			fraction = LarderMath.Clamp01(fraction);
			pivot = LarderMath.Clamp01(pivot);
			if (fraction < pivot)
			{
				return LarderMath.Lerp(strength, 1f, fraction / pivot);
			}
			float num = 1f - pivot;
			if (!(num <= 0f))
			{
				return LarderMath.Lerp(1f, 1f / strength, (fraction - pivot) / num);
			}
			return 1f;
		}
	}
	public static class RestedRules
	{
		public static float Duration(float baseDuration, float perComfort, int comfort)
		{
			int num = ((comfort > 1) ? (comfort - 1) : 0);
			return baseDuration + perComfort * (float)num;
		}
	}
	public sealed class RecoverySettings
	{
		public static RecoverySettings Vanilla => new RecoverySettings();

		public float StaminaRegenMultiplier { get; set; } = 1f;

		public float LowStaminaRegenBonus { get; set; } = 1f;

		public float RegenCurveStrength { get; set; } = 1f;

		public float RegenCurvePivot { get; set; } = 0.5f;

		public float BlockingRegenFactor { get; set; } = 0.8f;
	}
	public struct StaminaRegenInput
	{
		public float StaminaRegen { get; set; }

		public float StaminaRegenTimeMultiplier { get; set; }

		public float Stamina { get; set; }

		public float MaxStamina { get; set; }

		public float StatusEffectMultiplier { get; set; }

		public float VigorPercent { get; set; }

		public float ExtraStaminaPercent { get; set; }

		public float SneakPercent { get; set; }

		public bool Blocking { get; set; }

		public float WorldRegenRate { get; set; }
	}
	public static class StaminaRegenRules
	{
		public const float GameBlockingRegenFactor = 0.8f;

		public static float ExtraStamina(float maxStamina, float baseStamina, float skillBonus, bool countFoodStaminaOnly, float foodStamina)
		{
			if (!countFoodStaminaOnly)
			{
				return maxStamina - baseStamina - skillBonus;
			}
			return foodStamina;
		}

		public static float ExtraStaminaBonus(float extraStamina, float perPoint)
		{
			if (perPoint == 0f)
			{
				return 0f;
			}
			return ((extraStamina > 0f) ? extraStamina : 0f) * perPoint;
		}

		public static float SneakBonus(float bonusPercent, bool crouching, bool sneakingWhileMoving, float sneakSkillFactor)
		{
			if (bonusPercent == 0f || !crouching || sneakingWhileMoving)
			{
				return 0f;
			}
			return bonusPercent * sneakSkillFactor;
		}

		public static float HookMultiplier(float statusEffectMultiplier, float vigorPercent, float extraStaminaPercent, float sneakPercent, float curveFactor, bool blocking, float blockingFactor)
		{
			float num = statusEffectMultiplier + (vigorPercent + extraStaminaPercent + sneakPercent) / 100f;
			num *= curveFactor;
			if (blocking)
			{
				num *= blockingFactor / 0.8f;
			}
			return num;
		}

		public static float PerSecond(StaminaRegenInput input, RecoverySettings settings)
		{
			float num = input.StaminaRegen * LarderMath.NonNegative(settings.StaminaRegenMultiplier);
			float num2 = input.StaminaRegenTimeMultiplier * LarderMath.NonNegative(settings.LowStaminaRegenBonus);
			float num3 = ((input.MaxStamina > 0f) ? (input.Stamina / input.MaxStamina) : 1f);
			float num4 = num + (1f - num3) * num * num2;
			float num5 = HookMultiplier(curveFactor: RegenCurve.Factor(num3, settings.RegenCurveStrength, settings.RegenCurvePivot), statusEffectMultiplier: input.StatusEffectMultiplier, vigorPercent: input.VigorPercent, extraStaminaPercent: input.ExtraStaminaPercent, sneakPercent: input.SneakPercent, blocking: input.Blocking, blockingFactor: settings.BlockingRegenFactor);
			if (input.Blocking)
			{
				num5 *= 0.8f;
			}
			return num4 * num5 * input.WorldRegenRate;
		}

		public static float RestrictedFraction(bool encumbered, bool swimming, bool onGround, bool swimDelayElapsed, float encumberedFraction, float swimmingFraction)
		{
			if (encumbered)
			{
				return LarderMath.Clamp01(encumberedFraction);
			}
			if (!swimming || onGround)
			{
				return 0f;
			}
			if (!swimDelayElapsed)
			{
				return 0f;
			}
			return LarderMath.Clamp01(swimmingFraction);
		}

		public static bool SwimDelayElapsed(float now, float lastStroke, float delay)
		{
			return now - lastStroke >= LarderMath.NonNegative(delay);
		}

		public static float Delay(float configured)
		{
			return LarderMath.NonNegative(configured);
		}
	}
}
namespace ExtraPotions.Larder.Kitchen
{
	public static class KitchenRules
	{
		public static float RecipeTime(float? stationEntry, float ownTime, float multiplier)
		{
			return (stationEntry ?? ownTime) * LarderMath.NonNegative(multiplier);
		}

		public static bool CanBurn(bool stationCanOvercook, bool foodCanBurn)
		{
			return stationCanOvercook && foodCanBurn;
		}

		public static float FermentationDuration(float barrelOwn, float configured)
		{
			if (!(configured > 0f))
			{
				return barrelOwn;
			}
			return configured;
		}

		public static int BatchYield(int recipeOwn, int configured)
		{
			if (configured <= 0)
			{
				return recipeOwn;
			}
			return configured;
		}
	}
}
namespace ExtraPotions.Larder.Foods
{
	public static class FoodDuration
	{
		public static float BurnTime(float itemDuration, float durationModifier)
		{
			return itemDuration * LarderMath.NonNegative(durationModifier);
		}

		public static float RunDown(float timeLeft, float seconds, float foodRate, bool endless)
		{
			if (endless)
			{
				return timeLeft;
			}
			float num = timeLeft - seconds * LarderMath.NonNegative(foodRate);
			if (!(num > 0f))
			{
				return 0f;
			}
			return num;
		}
	}
	public readonly struct FoodStats : IEquatable<FoodStats>
	{
		public float Health { get; }

		public float Stamina { get; }

		public float Eitr { get; }

		public float Duration { get; }

		public float HealthRegen { get; }

		public FoodStats(float health, float stamina, float eitr, float duration, float healthRegen)
		{
			Health = health;
			Stamina = stamina;
			Eitr = eitr;
			Duration = duration;
			HealthRegen = healthRegen;
		}

		public bool Equals(FoodStats other)
		{
			if (Health == other.Health && Stamina == other.Stamina && Eitr == other.Eitr && Duration == other.Duration)
			{
				return HealthRegen == other.HealthRegen;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return HashCode.Combine(Health, Stamina, Eitr, Duration, HealthRegen);
		}

		public override string ToString()
		{
			return $"{Health}/{Stamina}/{Eitr} {Duration}s regen {HealthRegen}";
		}
	}
	public readonly struct FoodModifiers
	{
		public static FoodModifiers Vanilla => new FoodModifiers(1f, 1f, 1f, 1f, 1f);

		public float Health { get; }

		public float Stamina { get; }

		public float Eitr { get; }

		public float Duration { get; }

		public float HealthRegen { get; }

		public bool IsVanilla
		{
			get
			{
				if (Health == 1f && Stamina == 1f && Eitr == 1f && Duration == 1f)
				{
					return HealthRegen == 1f;
				}
				return false;
			}
		}

		public FoodModifiers(float health, float stamina, float eitr, float duration, float healthRegen)
		{
			Health = health;
			Stamina = stamina;
			Eitr = eitr;
			Duration = duration;
			HealthRegen = healthRegen;
		}
	}
	public static class FoodValues
	{
		public static FoodStats Apply(FoodStats configured, FoodModifiers modifiers)
		{
			return new FoodStats(configured.Health * LarderMath.NonNegative(modifiers.Health), configured.Stamina * LarderMath.NonNegative(modifiers.Stamina), configured.Eitr * LarderMath.NonNegative(modifiers.Eitr), configured.Duration * LarderMath.NonNegative(modifiers.Duration), configured.HealthRegen * LarderMath.NonNegative(modifiers.HealthRegen));
		}

		public static bool ShouldWrite(bool customizedNow, bool writtenBefore)
		{
			return customizedNow || writtenBefore;
		}

		public static float KeepProgress(float elapsed, float oldDuration, float newDuration)
		{
			return ((oldDuration > 0f) ? (elapsed / oldDuration) : 0f) * newDuration;
		}

		public static float Vigor(float vigor, float configuredStamina, float staminaModifier, float perStaminaPoint, float multiplier)
		{
			float num = configuredStamina * LarderMath.NonNegative(staminaModifier);
			return (vigor + num * perStaminaPoint) * multiplier;
		}

		public static float EitrVigor(float eitrVigor, float configuredEitr, float eitrModifier, float perEitrPoint, float multiplier)
		{
			return Vigor(eitrVigor, configuredEitr, eitrModifier, perEitrPoint, multiplier);
		}
	}
	public static class SettingTemplates
	{
		public const string Food = "food";

		public const string Mead = "mead";

		public const string Station = "station";

		public const string Recipe = "recipe";

		public static readonly IReadOnlyDictionary<string, string> SectionPrefix;

		public static readonly IReadOnlyList<(string Kind, string Key, string Help)> All;

		private static readonly Dictionary<(string, string), string> help;

		static SettingTemplates()
		{
			SectionPrefix = new Dictionary<string, string>
			{
				["food"] = "Food: ",
				["mead"] = "Mead: ",
				["station"] = "Station: "
			};
			All = new(string, string, string)[17]
			{
				("food", "Health", "Health {0} adds to your maximum while it lasts. Health Modifier in 2 - Foods applies on top. The game's value is the default."),
				("food", "Stamina", "Stamina {0} adds to your maximum while it lasts. Stamina Modifier in 2 - Foods applies on top. The game's value is the default."),
				("food", "Duration", "Seconds {0} lasts after eating. Duration Modifier in 2 - Foods and Food Rate in 5 - Exertion also apply. The game's value is the default."),
				("food", "HealthRegen", "Health {0} restores on each regeneration tick while it lasts. Health Regen Modifier in 2 - Foods applies on top. The game's value is the default."),
				("food", "Eitr", "Eitr {0} adds to your maximum while it lasts. Eitr Modifier in 2 - Foods applies on top. The game's value is the default."),
				("food", "Vigor", "Extra Vigor of {0}: percent added to stamina regeneration while the food is active, on top of its Stamina times Vigor Per Stamina Point. Does not fade with the food. Stacks with Regen Per Extra Stamina Point."),
				("food", "EitrVigor", "Extra Eitr Vigor of {0}: percent added to eitr regeneration while the food is active, on top of its Eitr times Eitr Vigor Per Eitr Point. Does not fade with the food."),
				("mead", "Duration", "Duration of {0} effect in seconds. While it runs, neither this mead nor another of its group (the healing meads, for example) can be drunk, so this is also the mead's cooldown."),
				("mead", "HealthOverTime", "Total health restored over time by {0}."),
				("mead", "StaminaOverTime", "Total stamina restored over time by {0}."),
				("mead", "EitrOverTime", "Total eitr restored over time by {0}."),
				("mead", "HealthRegenMultiplier", "Health regeneration multiplier while {0} lasts (1 = no change)."),
				("mead", "StaminaRegenMultiplier", "Stamina regeneration multiplier while {0} lasts (1 = no change). Combines with the stamina rules in 4 - Recovery, like the game's own meads."),
				("mead", "EitrRegenMultiplier", "Eitr regeneration multiplier while {0} lasts (1 = no change). Combines with the eitr rules in 4 - Recovery."),
				("mead", "RunStaminaModifier", "Added fraction of the run stamina drain while {0} lasts: -0.2 makes running 20% cheaper."),
				("mead", "JumpStaminaModifier", "Added fraction of the jump stamina cost while {0} lasts: -0.2 makes jumping 20% cheaper."),
				("station", "recipe", "Seconds {0} takes to cook into {1} on this station. Cook Time Multiplier in 6 - Kitchen applies on top.")
			};
			help = new Dictionary<(string, string), string>();
			foreach (var (item, item2, value) in All)
			{
				help[(item, item2)] = value;
			}
		}

		public static string Help(string kind, string key, params object[] arguments)
		{
			return string.Format(CultureInfo.InvariantCulture, help[(kind, key)], arguments);
		}

		public static string HeadingKey(string kind)
		{
			return "tpl_" + kind + "_heading";
		}

		public static string NameKey(string kind, string key)
		{
			return "tpl_" + kind + "__" + key.ToLowerInvariant() + "_name";
		}

		public static string HelpKey(string kind, string key)
		{
			return "tpl_" + kind + "__" + key.ToLowerInvariant() + "_help";
		}

		public static string Heading(string kind)
		{
			return SectionPrefix[kind] + "{0}";
		}
	}
}
namespace ExtraPotions.Larder.Exertion
{
	public static class BaseValues
	{
		public const float DefaultHealth = 25f;

		public const float DefaultStamina = 75f;

		public static float Effective(float own, float configured, float defaultValue)
		{
			if (!LarderMath.Approximately(configured, defaultValue))
			{
				return configured;
			}
			return own;
		}

		public static float SkillStamina(ExertionSettings settings, float run, float jump, float sneak, float swim, float fishing)
		{
			return Bonus(settings.RunSkillStamina, run) + Bonus(settings.JumpSkillStamina, jump) + Bonus(settings.SneakSkillStamina, sneak) + Bonus(settings.SwimSkillStamina, swim) + Bonus(settings.FishingSkillStamina, fishing);
		}

		private static float Bonus(float atSkill100, float skillFactor)
		{
			if (atSkill100 != 0f)
			{
				return atSkill100 * skillFactor;
			}
			return 0f;
		}
	}
	public enum CostSite
	{
		Run,
		Jump,
		Dodge,
		Block,
		Attack,
		Tool,
		Sneak,
		Swim,
		Encumbered,
		FishingPull,
		FishingHooked,
		Harpoon
	}
	public readonly struct CostContext
	{
		public bool OutOfCombat { get; }

		public bool SneakingIsFree { get; }

		public float SkillFactor { get; }

		public CostContext(bool outOfCombat, bool sneakingIsFree, float skillFactor)
		{
			OutOfCombat = outOfCombat;
			SneakingIsFree = sneakingIsFree;
			SkillFactor = skillFactor;
		}
	}
	public static class CostRules
	{
		public static bool OutOfCombat(bool targeted, bool sensed, bool attacking)
		{
			if (!targeted && !sensed)
			{
				return !attacking;
			}
			return false;
		}

		public static float OutOfCombatFactor(bool outOfCombat, float outOfCombatCost)
		{
			if (outOfCombatCost == 1f)
			{
				return 1f;
			}
			if (!outOfCombat)
			{
				return 1f;
			}
			return LarderMath.NonNegative(outOfCombatCost);
		}

		public static float SkillDiscountFactor(float discountPercent, float skillFactor)
		{
			if (discountPercent == 0f)
			{
				return 1f;
			}
			return Math.Max(0f, 1f - discountPercent / 100f * skillFactor);
		}

		public static bool SneakingIsFree(bool enabled, bool inStealthRange, bool sensed, bool targeted)
		{
			if (enabled && !inStealthRange && !sensed)
			{
				return !targeted;
			}
			return false;
		}

		public static float Multiplier(CostSite site, CostContext context, ExertionSettings settings)
		{
			switch (site)
			{
			case CostSite.Run:
				return LarderMath.NonNegative(settings.RunCost) * OutOfCombatFactor(context.OutOfCombat, settings.OutOfCombatRunCost);
			case CostSite.Jump:
				return LarderMath.NonNegative(settings.JumpCost) * OutOfCombatFactor(context.OutOfCombat, settings.OutOfCombatJumpCost) * SkillDiscountFactor(settings.SkillDiscount, context.SkillFactor);
			case CostSite.Dodge:
				return LarderMath.NonNegative(settings.DodgeCost) * OutOfCombatFactor(context.OutOfCombat, settings.OutOfCombatDodgeCost) * SkillDiscountFactor(settings.SkillDiscount, context.SkillFactor);
			case CostSite.Block:
				return LarderMath.NonNegative(settings.BlockCost) * SkillDiscountFactor(settings.SkillDiscount, context.SkillFactor);
			case CostSite.Sneak:
				if (!context.SneakingIsFree || !settings.FreeSneakingWithoutEnemies)
				{
					return LarderMath.NonNegative(settings.SneakCost) * OutOfCombatFactor(context.OutOfCombat, settings.OutOfCombatSneakCost);
				}
				return 0f;
			case CostSite.Attack:
				return LarderMath.NonNegative(settings.AttackCost);
			case CostSite.Tool:
				return LarderMath.NonNegative(settings.ToolCost);
			case CostSite.Swim:
				return LarderMath.NonNegative(settings.SwimCost);
			case CostSite.Encumbered:
				return LarderMath.NonNegative(settings.EncumberedCost);
			case CostSite.FishingPull:
				return LarderMath.NonNegative(settings.FishingPullCost);
			case CostSite.FishingHooked:
				return LarderMath.NonNegative(settings.FishingHookedCost);
			case CostSite.Harpoon:
				return LarderMath.NonNegative(settings.HarpoonCost);
			default:
				return 1f;
			}
		}

		public static bool JumpAllowed(float stamina, float jumpStaminaUsage, float multiplier)
		{
			float num = jumpStaminaUsage * multiplier;
			if (!(num <= 0f))
			{
				return stamina > num;
			}
			return true;
		}
	}
	public enum ExertionSkill
	{
		Run,
		Jump,
		Sneak,
		Swim,
		Fishing,
		Other
	}
	public static class ExertionRules
	{
		public static float DrowningDamage(float damage, float multiplier, bool isPlayer, bool isDrowning)
		{
			if (!(isPlayer && isDrowning))
			{
				return damage;
			}
			return damage * LarderMath.NonNegative(multiplier);
		}

		public static float SkillGain(ExertionSkill skill, float factor, ExertionSettings settings)
		{
			return factor * LarderMath.NonNegative(Multiplier(skill, settings));
		}

		private static float Multiplier(ExertionSkill skill, ExertionSettings settings)
		{
			return skill switch
			{
				ExertionSkill.Run => settings.RunSkillGain, 
				ExertionSkill.Jump => settings.JumpSkillGain, 
				ExertionSkill.Sneak => settings.SneakSkillGain, 
				ExertionSkill.Swim => settings.SwimSkillGain, 
				ExertionSkill.Fishing => settings.FishingSkillGain, 
				_ => 1f, 
			};
		}
	}
	public sealed class ExertionSettings
	{
		public float RunCost { get; set; } = 1f;

		public float JumpCost { get; set; } = 1f;

		public float DodgeCost { get; set; } = 1f;

		public float BlockCost { get; set; } = 1f;

		public float AttackCost { get; set; } = 1f;

		public float SneakCost { get; set; } = 1f;

		public float SwimCost { get; set; } = 1f;

		public float EncumberedCost { get; set; } = 1f;

		public float ToolCost { get; set; } = 1f;

		public float FishingPullCost { get; set; } = 1f;

		public float FishingHookedCost { get; set; } = 1f;

		public float HarpoonCost { get; set; } = 1f;

		public float DrowningDamage { get; set; } = 1f;

		public float OutOfCombatRunCost { get; set; } = 1f;

		public float OutOfCombatJumpCost { get; set; } = 1f;

		public float OutOfCombatDodgeCost { get; set; } = 1f;

		public float OutOfCombatSneakCost { get; set; } = 1f;

		public bool FreeSneakingWithoutEnemies { get; set; }

		public float SkillDiscount { get; set; }

		public float BaseHealth { get; set; } = 25f;

		public float BaseStamina { get; set; } = 75f;

		public float RunSkillStamina { get; set; }

		public float JumpSkillStamina { get; set; }

		public float SneakSkillStamina { get; set; }

		public float SwimSkillStamina { get; set; }

		public float FishingSkillStamina { get; set; }

		public float RunSkillGain { get; set; } = 1f;

		public float JumpSkillGain { get; set; } = 1f;

		public float SneakSkillGain { get; set; } = 1f;

		public float SwimSkillGain { get; set; } = 1f;

		public float FishingSkillGain { get; set; } = 1f;

		public float FoodRate { get; set; }

		public float StaminaRate { get; set; }

		public float MoveStaminaRate { get; set; }

		public float StaminaRegenRate { get; set; }

		public bool ChangesCosts
		{
			get
			{
				if (RunCost == 1f && JumpCost == 1f && DodgeCost == 1f && BlockCost == 1f && AttackCost == 1f && SneakCost == 1f && SwimCost == 1f && EncumberedCost == 1f && ToolCost == 1f && FishingPullCost == 1f && FishingHookedCost == 1f && HarpoonCost == 1f && OutOfCombatRunCost == 1f && OutOfCombatJumpCost == 1f && OutOfCombatDodgeCost == 1f && OutOfCombatSneakCost == 1f && !FreeSneakingWithoutEnemies)
				{
					return SkillDiscount != 0f;
				}
				return true;
			}
		}

		public bool OverridesWorldRates
		{
			get
			{
				if (!(FoodRate > 0f) && !(StaminaRate > 0f) && !(MoveStaminaRate > 0f))
				{
					return StaminaRegenRate > 0f;
				}
				return true;
			}
		}
	}
	public sealed class IgnoredCreatures
	{
		private readonly HashSet<string> names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public IgnoredCreatures(string specification)
		{
			string[] array = (specification ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					names.Add(text);
				}
			}
		}

		public bool Contains(string prefab, string displayedName)
		{
			if (string.IsNullOrEmpty(prefab) || !names.Contains(prefab))
			{
				if (!string.IsNullOrEmpty(displayedName))
				{
					return names.Contains(displayedName);
				}
				return false;
			}
			return true;
		}
	}
	[Flags]
	public enum StaminaBlock
	{
		None = 0,
		Swimming = 1,
		Attacking = 2,
		Dodging = 4,
		WallRunning = 8,
		Encumbered = 0x10
	}
	public static class SafeStaminaRules
	{
		public static bool AllowsBlockedRegeneration(StaminaBlock state, bool swimming, bool attacks)
		{
			return AllowsBlockedRegeneration(state, swimming, attacks, encumbered: false);
		}

		public static bool AllowsBlockedRegeneration(StaminaBlock state, bool swimming, bool attacks, bool encumbered)
		{
			bool flag = (state & StaminaBlock.Encumbered) != 0;
			if (flag && !encumbered)
			{
				return false;
			}
			if ((state & StaminaBlock.Swimming) != StaminaBlock.None)
			{
				return swimming;
			}
			if ((state & (StaminaBlock.Attacking | StaminaBlock.Dodging)) != StaminaBlock.None)
			{
				return attacks;
			}
			if (!flag)
			{
				return (state & StaminaBlock.WallRunning) != 0;
			}
			return true;
		}
	}
	public static class WorldRates
	{
		public static float Effective(float world, float configured)
		{
			if (!(configured > 0f))
			{
				return world;
			}
			return configured;
		}
	}
}
namespace ExtraPotions.Larder.Eating
{
	public readonly struct AutoEatCandidate
	{
		public string SharedName { get; }

		public bool InFoodSlot { get; }

		public int Order { get; }

		public AutoEatCandidate(string sharedName, bool inFoodSlot, int order)
		{
			SharedName = sharedName;
			InFoodSlot = inFoodSlot;
			Order = order;
		}
	}
	public static class AutoEat
	{
		public const bool AsFromInventory = true;

		public const float ExpiringAt = 1f;

		public static bool Active(bool allowAutoEat, bool ownAutoEat, bool isLocalPlayer)
		{
			return allowAutoEat && ownAutoEat && isLocalPlayer;
		}

		public static int Expiring(IReadOnlyList<float> timesLeft)
		{
			for (int i = 0; i < timesLeft.Count; i++)
			{
				if (timesLeft[i] <= 1f)
				{
					return i;
				}
			}
			return -1;
		}

		public static int Select(string sharedName, IReadOnlyList<AutoEatCandidate> items)
		{
			if (string.IsNullOrEmpty(sharedName))
			{
				return -1;
			}
			int num = -1;
			for (int i = 0; i < items.Count; i++)
			{
				AutoEatCandidate a = items[i];
				if (!(a.SharedName != sharedName) && (num < 0 || Before(a, items[num])))
				{
					num = i;
				}
			}
			return num;
		}

		private static bool Before(AutoEatCandidate a, AutoEatCandidate b)
		{
			if (a.InFoodSlot != b.InFoodSlot)
			{
				return a.InFoodSlot;
			}
			return a.Order < b.Order;
		}
	}
	public static class EatAgain
	{
		public const float GameFraction = 0.5f;

		public static bool CanEatAgain(float timeLeft, float burnTime, float fraction, bool eatAnything)
		{
			float num = (eatAnything ? 1f : LarderMath.Clamp01(fraction));
			return timeLeft < burnTime * num;
		}
	}
	public static class FoodDegradation
	{
		public const float GameCurve = 0.3f;

		public static float Strength(float timeLeft, float burnTime, float curve, bool disabled)
		{
			if (disabled)
			{
				return 1f;
			}
			curve = LarderMath.NonNegative(curve);
			if (curve <= 0f)
			{
				return 1f;
			}
			return (float)Math.Pow((burnTime > 0f) ? LarderMath.Clamp01(timeLeft / burnTime) : 0f, curve);
		}

		public static bool Changes(bool disabled, float curve)
		{
			if (!disabled)
			{
				return !LarderMath.Approximately(LarderMath.NonNegative(curve), 0.3f);
			}
			return true;
		}

		public static FoodStats Faded(FoodStats full, float strength)
		{
			return new FoodStats(full.Health * strength, full.Stamina * strength, full.Eitr * strength, full.Duration, full.HealthRegen);
		}
	}
	public enum EatOutcome
	{
		Add,
		ReplaceMostDepleted,
		RefreshSame,
		NoMore,
		Full
	}
	public static class FoodSlots
	{
		public const int GameSlots = 3;

		public const int MinSlots = 1;

		public const int MaxSlots = 5;

		public static int Clamp(int slots)
		{
			if (slots >= 1)
			{
				if (slots <= 5)
				{
					return slots;
				}
				return 5;
			}
			return 1;
		}

		public static EatOutcome Decide(int slots, int held, bool hasSame, bool sameCanEatAgain, bool anyCanEatAgain, bool eatAnything)
		{
			if (hasSame)
			{
				if (!(sameCanEatAgain || eatAnything))
				{
					return EatOutcome.NoMore;
				}
				return EatOutcome.RefreshSame;
			}
			if (held < Clamp(slots))
			{
				return EatOutcome.Add;
			}
			if (!(anyCanEatAgain || eatAnything))
			{
				return EatOutcome.Full;
			}
			return EatOutcome.ReplaceMostDepleted;
		}

		public static int Kept(int slots, int held)
		{
			return held;
		}

		public static int HudSlots(int slots, int held)
		{
			int num = Clamp(slots);
			if (held <= num)
			{
				return num;
			}
			return held;
		}

		public static int MostDepleted(IReadOnlyList<float> timesLeft, IReadOnlyList<bool> canEatAgain, bool eatAnything)
		{
			int num = -1;
			for (int i = 0; i < timesLeft.Count; i++)
			{
				if (canEatAgain[i] && (num < 0 || timesLeft[i] < timesLeft[num]))
				{
					num = i;
				}
			}
			if (num >= 0 || !eatAnything)
			{
				return num;
			}
			for (int j = 0; j < timesLeft.Count; j++)
			{
				if (num < 0 || timesLeft[j] < timesLeft[num])
				{
					num = j;
				}
			}
			return num;
		}
	}
	public enum FoodTopUpReason
	{
		Spawn,
		Retrieval,
		Automatic
	}
	public static class FoodTopUpRules
	{
		public static bool Allowed(FoodTopUpReason reason, bool onSpawnAndRetrieval, bool automatic)
		{
			switch (reason)
			{
			case FoodTopUpReason.Spawn:
			case FoodTopUpReason.Retrieval:
				return onSpawnAndRetrieval;
			case FoodTopUpReason.Automatic:
				return automatic;
			default:
				return false;
			}
		}
	}
}
namespace ExtraPotions.Larder.Cooking
{
	public enum SlotState
	{
		Cooking,
		Done,
		Burnt
	}
	public static class CookClock
	{
		public static float Advance(float cooked, float elapsed, float cookTime, float speed, float extraBurn)
		{
			float num = 1f / (1f + extraBurn);
			if (cooked >= cookTime)
			{
				return cooked + elapsed * num;
			}
			float num2 = (cookTime - cooked) / speed;
			if (elapsed <= num2)
			{
				return cooked + elapsed * speed;
			}
			return cookTime + (elapsed - num2) * num;
		}

		public static bool IsVanilla(float speed, float extraBurn)
		{
			if (speed <= 1f)
			{
				return extraBurn <= 0f;
			}
			return false;
		}

		public static SlotState State(float cooked, float cookTime, bool canBurn)
		{
			if (canBurn && cooked > cookTime * 2f)
			{
				return SlotState.Burnt;
			}
			if (!(cooked > cookTime))
			{
				return SlotState.Cooking;
			}
			return SlotState.Done;
		}

		public static float SecondsUntilDone(float cooked, float cookTime, float speed)
		{
			if (!(cooked >= cookTime))
			{
				return (cookTime - cooked) / speed;
			}
			return 0f;
		}

		public static float SecondsUntilBurnt(float cooked, float cookTime, float extraBurn)
		{
			float num = ((cooked > cookTime) ? cooked : cookTime);
			float num2 = cookTime * 2f - num;
			if (!(num2 > 0f))
			{
				return 0f;
			}
			return num2 * (1f + extraBurn);
		}
	}
	public static class CookingPerks
	{
		public const float MaxLevel = 100f;

		public const float DefaultCookingSpeed = 50f;

		public const float DefaultExtraBurnTime = 100f;

		public const float DefaultFermentingSpeed = 30f;

		public const float DefaultExtraFoodChance = 50f;

		public const int DefaultExtraFoodAmount = 1;

		public const float DefaultIngredientSaveChance = 10f;

		public static float Factor(float level)
		{
			return LarderMath.Clamp01(level / 100f);
		}

		public static float CookingSpeed(float percentAt100, float level)
		{
			return 1f + Share(percentAt100, level);
		}

		public static float ExtraBurnTime(float percentAt100, float level)
		{
			return Share(percentAt100, level);
		}

		public static float FermentingSpeed(float percentAt100, float level)
		{
			return 1f + Share(percentAt100, level);
		}

		public static float ExtraFoodChance(float percentAt100, float level)
		{
			return LarderMath.Clamp01(Share(percentAt100, level));
		}

		public static int ExtraFoodAmount(int configured)
		{
			if (configured >= 1)
			{
				return configured;
			}
			return 1;
		}

		public static float IngredientSaveChance(float percentAt100, float level)
		{
			return LarderMath.Clamp01(Share(percentAt100, level));
		}

		private static float Share(float percentAt100, float level)
		{
			return LarderMath.NonNegative(percentAt100) / 100f * Factor(level);
		}
	}
	public static class FermentCountdown
	{
		public static string? Format(double scaledElapsed, double duration, double speed)
		{
			if (double.IsNaN(scaledElapsed) || double.IsInfinity(scaledElapsed) || scaledElapsed < 0.0 || double.IsNaN(duration) || double.IsInfinity(duration) || duration <= 0.0 || double.IsNaN(speed) || double.IsInfinity(speed) || speed <= 0.0 || scaledElapsed > duration)
			{
				return null;
			}
			double num = Math.Ceiling((duration - scaledElapsed) / speed);
			if (num > 2147483647.0)
			{
				return null;
			}
			int num2 = (int)num;
			if (num2 < 3600)
			{
				return string.Format(CultureInfo.InvariantCulture, "{0}:{1:00}", num2 / 60, num2 % 60);
			}
			return string.Format(CultureInfo.InvariantCulture, "{0}:{1:00}:{2:00}", num2 / 3600, num2 / 60 % 60, num2 % 60);
		}
	}
	public sealed class FermenterCredits
	{
		public const int Capacity = 4096;

		private const int MaxKeyLength = 160;

		private readonly Dictionary<string, long> starts = new Dictionary<string, long>(StringComparer.Ordinal);

		public int Count => starts.Count;

		public bool CanCredit(long world, string barrel, long start)
		{
			if (!TryKey(world, barrel, out string key) || start <= 0)
			{
				return false;
			}
			if (!starts.TryGetValue(key, out var value))
			{
				return starts.Count < 4096;
			}
			return start > value;
		}

		public bool TryCredit(long world, string barrel, long start)
		{
			if (!CanCredit(world, barrel, start))
			{
				return false;
			}
			TryKey(world, barrel, out string key);
			starts[key] = start;
			return true;
		}

		public string Save()
		{
			StringBuilder stringBuilder = new StringBuilder("1");
			foreach (KeyValuePair<string, long> start in starts)
			{
				stringBuilder.Append('\n').Append(start.Key).Append('\t')
					.Append(start.Value.ToString(CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		public static bool TryRestore(string text, out FermenterCredits history)
		{
			history = null;
			FermenterCredits fermenterCredits = new FermenterCredits();
			if (string.IsNullOrEmpty(text))
			{
				history = fermenterCredits;
				return true;
			}
			if (text.Length > 745473)
			{
				return false;
			}
			string[] array = text.Split('\n');
			if (array[0] != "1" || array.Length > 4097)
			{
				return false;
			}
			for (int i = 1; i < array.Length; i++)
			{
				int num = array[i].IndexOf('\t');
				if (num <= 0)
				{
					return false;
				}
				string text2 = array[i].Substring(0, num);
				int num2 = text2.IndexOf(':');
				if (num2 <= 0 || !long.TryParse(text2.Substring(0, num2), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !TryKey(result, text2.Substring(num2 + 1), out string key) || text2 != key || !long.TryParse(array[i].Substring(num + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || result2 <= 0 || fermenterCredits.starts.ContainsKey(text2))
				{
					return false;
				}
				fermenterCredits.starts.Add(text2, result2);
			}
			history = fermenterCredits;
			return true;
		}

		private static bool TryKey(long world, string barrel, out string key)
		{
			key = null;
			if (world == 0L || string.IsNullOrEmpty(barrel) || barrel.Length > 128 || barrel.IndexOf('\n') >= 0 || barrel.IndexOf('\r') >= 0 || barrel.IndexOf('\t') >= 0)
			{
				return false;
			}
			key = world.ToString(CultureInfo.InvariantCulture) + ":" + barrel;
			return key.Length <= 160;
		}
	}
	public static class FermentRules
	{
		public static double ScaledElapsed(double elapsed, float speed)
		{
			if (!(elapsed <= 0.0))
			{
				return elapsed * (double)speed;
			}
			return elapsed;
		}

		public static bool Ready(double elapsed, float duration, float speed)
		{
			if (elapsed > 0.0)
			{
				return ScaledElapsed(elapsed, speed) >= (double)duration;
			}
			return false;
		}
	}
	public static class RecipeQuality
	{
		public struct Stack
		{
			public string Name;

			public int Quality;

			public int Amount;

			public Stack(string name, int quality, int amount)
			{
				Name = name;
				Quality = quality;
				Amount = amount;
			}
		}

		public static bool TracksEveryIngredient(bool hasRecipe, bool requireOnlyOneIngredient)
		{
			if (hasRecipe)
			{
				return !requireOnlyOneIngredient;
			}
			return false;
		}

		public static bool CountEveryQuality(bool trackingEveryIngredient, int requestedQuality, int maxQuality)
		{
			if (trackingEveryIngredient && requestedQuality == 1)
			{
				return maxQuality <= 1;
			}
			return false;
		}

		public static int Count(IEnumerable<Stack> stacks, string name, int requestedQuality, int maxQuality, bool trackingEveryIngredient)
		{
			if (name == null || stacks == null)
			{
				return 0;
			}
			bool flag = CountEveryQuality(trackingEveryIngredient, requestedQuality, maxQuality);
			int num = 0;
			foreach (Stack stack in stacks)
			{
				if (!(stack.Name != name) && stack.Amount > 0 && (flag || requestedQuality < 0 || stack.Quality == requestedQuality))
				{
					num += stack.Amount;
				}
			}
			return num;
		}
	}
	public enum StationAddDecision
	{
		New,
		Accepted,
		Rejected,
		Stale
	}
	public sealed class StationAddReceipts
	{
		private readonly struct Receipt
		{
			public readonly long Sequence;

			public readonly bool Accepted;

			public Receipt(long sequence, bool accepted)
			{
				Sequence = sequence;
				Accepted = accepted;
			}
		}

		public const int Capacity = 256;

		private const int MaxSerializedLength = 11009;

		private readonly SortedDictionary<long, Receipt> receipts = new SortedDictionary<long, Receipt>();

		public int Count => receipts.Count;

		public StationAddDecision Check(long character, long sequence)
		{
			if (character == 0L || sequence <= 0)
			{
				return StationAddDecision.Stale;
			}
			if (!receipts.TryGetValue(character, out var value))
			{
				if (receipts.Count >= 256)
				{
					return StationAddDecision.Rejected;
				}
				return StationAddDecision.New;
			}
			if (sequence < value.Sequence)
			{
				return StationAddDecision.Stale;
			}
			if (sequence > value.Sequence)
			{
				return StationAddDecision.New;
			}
			if (!value.Accepted)
			{
				return StationAddDecision.Rejected;
			}
			return StationAddDecision.Accepted;
		}

		public string Record(long character, long sequence, bool accepted)
		{
			Receipt value;
			if (Check(character, sequence) == StationAddDecision.New)
			{
				receipts[character] = new Receipt(sequence, accepted);
			}
			else if (!receipts.TryGetValue(character, out value) || value.Sequence != sequence || value.Accepted != accepted)
			{
				throw new InvalidOperationException("Only a new station-add request or its unchanged receipt can be recorded.");
			}
			return Save();
		}

		public static StationAddReceipts Parse(string? serialized)
		{
			StationAddReceipts stationAddReceipts = new StationAddReceipts();
			if (string.IsNullOrEmpty(serialized))
			{
				return stationAddReceipts;
			}
			if (serialized.Length > 11009)
			{
				throw InvalidData();
			}
			string[] array = serialized.Split('\n');
			if (array[0] != "1" || array.Length > 257)
			{
				throw InvalidData();
			}
			for (int i = 1; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(':');
				if (array2.Length != 3 || !TryCharacter(array2[0], out var parsed) || !TryPositive(array2[1], out var parsed2) || (array2[2] != "0" && array2[2] != "1") || stationAddReceipts.receipts.ContainsKey(parsed))
				{
					throw InvalidData();
				}
				stationAddReceipts.receipts.Add(parsed, new Receipt(parsed2, array2[2] == "1"));
			}
			return stationAddReceipts;
		}

		private string Save()
		{
			StringBuilder stringBuilder = new StringBuilder("1");
			foreach (KeyValuePair<long, Receipt> receipt in receipts)
			{
				stringBuilder.Append('\n').Append(receipt.Key.ToString(CultureInfo.InvariantCulture)).Append(':')
					.Append(receipt.Value.Sequence.ToString(CultureInfo.InvariantCulture))
					.Append(':')
					.Append(receipt.Value.Accepted ? '1' : '0');
			}
			return stringBuilder.ToString();
		}

		private static bool TryPositive(string value, out long parsed)
		{
			if (long.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out parsed) && parsed > 0)
			{
				return value == parsed.ToString(CultureInfo.InvariantCulture);
			}
			return false;
		}

		private static bool TryCharacter(string value, out long parsed)
		{
			if (long.TryParse(value, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out parsed) && parsed != 0L)
			{
				return value == parsed.ToString(CultureInfo.InvariantCulture);
			}
			return false;
		}

		private static FormatException InvalidData()
		{
			return new FormatException("Invalid station-add receipt ledger.");
		}
	}
}
namespace ExtraPotions.Larder.Cheats
{
	public enum LarderCheat
	{
		InstantKitchen,
		EndlessFood,
		EatAnything
	}
	public enum CheatBlock
	{
		None,
		NotAdmin,
		ProductDisabled,
		VanillaServer,
		AuthorityPending
	}
	public static class LarderCheats
	{
		public static IReadOnlyList<LarderCheat> All { get; } = new LarderCheat[3]
		{
			LarderCheat.InstantKitchen,
			LarderCheat.EndlessFood,
			LarderCheat.EatAnything
		};

		public static bool SafeValue(LarderCheat cheat)
		{
			return false;
		}

		public static bool Effective(LarderCheat cheat, CheatBlock block, bool value)
		{
			if (block != CheatBlock.None)
			{
				return SafeValue(cheat);
			}
			return value;
		}
	}
	public static class KitchenCheats
	{
		public static float RecipeTime(float time, bool instantKitchen)
		{
			if (!instantKitchen)
			{
				return time;
			}
			return 0f;
		}

		public static bool CanBurn(bool canBurn, bool instantKitchen)
		{
			if (canBurn)
			{
				return !instantKitchen;
			}
			return false;
		}

		public static float FermentationDuration(float duration, bool instantKitchen)
		{
			if (!instantKitchen)
			{
				return duration;
			}
			return 0f;
		}
	}
}