using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using ExtraPotions.Solstice.Calendar;
using ExtraPotions.Solstice.Effects;
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.5.0")]
[assembly: AssemblyInformationalVersion("0.1.5")]
[assembly: AssemblyProduct("Solstice.Core")]
[assembly: AssemblyTitle("Solstice.Core")]
[assembly: AssemblyVersion("0.1.5.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.Solstice
{
	public enum LegacyFileOutcome
	{
		None,
		Migrated,
		KeptNew,
		Failed
	}
	public sealed class LegacyFileResult
	{
		public LegacyFileOutcome Outcome { get; }

		public string? Backup { get; }

		public string? Problem { get; }

		internal LegacyFileResult(LegacyFileOutcome outcome, string? backup = null, string? problem = null)
		{
			Outcome = outcome;
			Backup = backup;
			Problem = problem;
		}
	}
	public static class LegacyFileMigration
	{
		public static LegacyFileResult PrepareSettings(string directory, string legacyName, string currentName)
		{
			LegacyFileResult legacyFileResult = Run(directory, legacyName, currentName);
			if (legacyFileResult.Outcome == LegacyFileOutcome.Failed)
			{
				throw new IOException("Legacy settings could not be carried over; initialization stopped before defaults were saved. " + legacyFileResult.Problem);
			}
			return legacyFileResult;
		}

		public static LegacyFileResult Run(string directory, string legacyName, string currentName)
		{
			if (string.IsNullOrEmpty(directory))
			{
				throw new ArgumentException("A config directory is required.", "directory");
			}
			if (string.IsNullOrEmpty(legacyName) || string.IsNullOrEmpty(currentName) || string.Equals(legacyName, currentName, StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException("Two different file names are required.");
			}
			string text = Path.Combine(directory, legacyName);
			string text2 = Path.Combine(directory, currentName);
			if (!File.Exists(text))
			{
				return new LegacyFileResult(LegacyFileOutcome.None);
			}
			if (File.Exists(text2))
			{
				return new LegacyFileResult(LegacyFileOutcome.KeptNew);
			}
			string text3 = text2 + ".migrate-" + Guid.NewGuid().ToString("N");
			try
			{
				byte[] array = File.ReadAllBytes(text);
				File.WriteAllBytes(text3, array);
				if (!((ReadOnlySpan<byte>)array).SequenceEqual((ReadOnlySpan<byte>)File.ReadAllBytes(text3)))
				{
					throw new IOException("The copied settings failed readback.");
				}
				if (File.Exists(text2))
				{
					return new LegacyFileResult(LegacyFileOutcome.KeptNew);
				}
				File.Move(text3, text2);
			}
			catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
			{
				return File.Exists(text2) ? new LegacyFileResult(LegacyFileOutcome.KeptNew) : new LegacyFileResult(LegacyFileOutcome.Failed, null, ex.Message);
			}
			finally
			{
				try
				{
					if (File.Exists(text3))
					{
						File.Delete(text3);
					}
				}
				catch (IOException)
				{
				}
				catch (UnauthorizedAccessException)
				{
				}
			}
			try
			{
				string text4 = FreeBackupName(text);
				File.Move(text, text4);
				return new LegacyFileResult(LegacyFileOutcome.Migrated, text4);
			}
			catch (Exception ex4) when (ex4 is IOException || ex4 is UnauthorizedAccessException)
			{
				return new LegacyFileResult(LegacyFileOutcome.Migrated, null, "The old file kept its name: " + ex4.Message);
			}
		}

		private static string FreeBackupName(string path)
		{
			string text = path + ".bak";
			if (!File.Exists(text))
			{
				return text;
			}
			for (int i = 1; i < 1000; i++)
			{
				string text2 = path + "." + i + ".bak";
				if (!File.Exists(text2))
				{
					return text2;
				}
			}
			throw new IOException("No free backup name for " + Path.GetFileName(path) + ".");
		}
	}
	[Flags]
	public enum SeasonFrameSystem
	{
		None = 0,
		WeatherListSwap = 1,
		EnvironmentVariants = 2,
		MusicInvalidate = 4,
		VisualsRepaint = 8,
		MinimapTint = 0x10
	}
	public static class SeasonFrame
	{
		private static readonly Stopwatch clock = Stopwatch.StartNew();

		public static SeasonFrameSystem Ran { get; private set; }

		public static bool DayMoved { get; set; }

		public static bool EnabledToggled { get; set; }

		public static long WeatherSwapTicks { get; private set; }

		public static long MusicTicks { get; private set; }

		public static void Mark(SeasonFrameSystem system)
		{
			Ran |= system;
		}

		public static long Stamp()
		{
			return clock.ElapsedTicks;
		}

		public static void Add(SeasonFrameSystem system, long startedAt)
		{
			Ran |= system;
			long num = clock.ElapsedTicks - startedAt;
			if (num < 0)
			{
				num = 0L;
			}
			switch (system)
			{
			case SeasonFrameSystem.WeatherListSwap:
				WeatherSwapTicks += num;
				break;
			case SeasonFrameSystem.MusicInvalidate:
				MusicTicks += num;
				break;
			}
		}

		public static void ClearWork()
		{
			Ran = SeasonFrameSystem.None;
			WeatherSwapTicks = 0L;
			MusicTicks = 0L;
		}

		public static int Milliseconds(long ticks)
		{
			if (ticks <= 0)
			{
				return 0;
			}
			long frequency = Stopwatch.Frequency;
			if (frequency <= 0)
			{
				return 0;
			}
			return (int)(ticks * 1000 / frequency);
		}

		public static string Describe(SeasonFrameSystem systems)
		{
			if (systems == SeasonFrameSystem.None)
			{
				return "none";
			}
			string text = "";
			if ((systems & SeasonFrameSystem.WeatherListSwap) != SeasonFrameSystem.None)
			{
				text = Join(text, "weather list swap");
			}
			if ((systems & SeasonFrameSystem.EnvironmentVariants) != SeasonFrameSystem.None)
			{
				text = Join(text, "environment variants");
			}
			if ((systems & SeasonFrameSystem.MusicInvalidate) != SeasonFrameSystem.None)
			{
				text = Join(text, "music invalidate");
			}
			if ((systems & SeasonFrameSystem.VisualsRepaint) != SeasonFrameSystem.None)
			{
				text = Join(text, "visuals repaint");
			}
			if ((systems & SeasonFrameSystem.MinimapTint) != SeasonFrameSystem.None)
			{
				text = Join(text, "minimap tint");
			}
			if (text.Length != 0)
			{
				return text;
			}
			return "none";
		}

		private static string Join(string text, string name)
		{
			if (text.Length != 0)
			{
				return text + ", " + name;
			}
			return name;
		}
	}
	public static class SolsticeCore
	{
		public const string PluginGuid = "com.meadworks.solstice";

		public const string LegacyPluginGuid = "com.extrapotions.solstice";

		public const string ProductName = "Solstice";

		public const string ProductVersion = "0.1.5";

		public const string Family = "Runestone";

		public const string TokenNamespace = "solstice";

		public const string TokenPrefix = "meadworks_solstice_";

		public const string SupportedGameVersion = "1.0.17";
	}
	public static class TickGuard
	{
		public const double WindowSeconds = 60.0;

		public static bool Report(ref double nextReportAt, double nowSeconds)
		{
			if (nowSeconds < nextReportAt)
			{
				return false;
			}
			nextReportAt = nowSeconds + 60.0;
			return true;
		}

		public static void Run(Action tick, ref double nextReportAt, double nowSeconds, Action<Exception> report)
		{
			if (tick == null)
			{
				return;
			}
			try
			{
				tick();
			}
			catch (Exception obj)
			{
				if (Report(ref nextReportAt, nowSeconds))
				{
					report?.Invoke(obj);
				}
			}
		}
	}
}
namespace ExtraPotions.Solstice.Weather
{
	public sealed class EnvironmentWeight
	{
		public string Name { get; }

		public float Weight { get; }

		public object? Source { get; }

		public EnvironmentWeight(string name, float weight, object? source = null)
		{
			Name = name ?? "";
			Weight = weight;
			Source = source;
		}
	}
	public sealed class EnvironmentAdd
	{
		public string Biome { get; }

		public string Environment { get; }

		public float Weight { get; }

		public EnvironmentAdd(string biome, string environment, float weight)
		{
			Biome = biome;
			Environment = environment;
			Weight = weight;
		}
	}
	public sealed class EnvironmentReplace
	{
		public string Environment { get; }

		public string ReplaceTo { get; }

		public EnvironmentReplace(string environment, string replaceTo)
		{
			Environment = environment;
			ReplaceTo = replaceTo;
		}
	}
	public sealed class EnvironmentRemove
	{
		public string Biome { get; }

		public string Environment { get; }

		public EnvironmentRemove(string biome, string environment)
		{
			Biome = biome;
			Environment = environment;
		}
	}
	public sealed class SeasonEnvironmentRules
	{
		public List<EnvironmentAdd> Add { get; } = new List<EnvironmentAdd>();

		public List<EnvironmentReplace> Replace { get; } = new List<EnvironmentReplace>();

		public List<EnvironmentRemove> Remove { get; } = new List<EnvironmentRemove>();

		public int Count => Add.Count + Replace.Count + Remove.Count;
	}
	public static class SeasonBiomeEnvironments
	{
		public static SeasonEnvironmentRules For(Season season)
		{
			SeasonEnvironmentRules seasonEnvironmentRules = new SeasonEnvironmentRules();
			switch (season)
			{
			case Season.Summer:
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Clear", "Clear Summer"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Misty", "Misty Summer"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("DeepForest Mist", "DeepForest Mist Summer"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Mistlands_clear", "Mistlands_clear Summer"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Heath clear", "Heath clear Summer"));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Meadows", "Heath clear", 2f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Black forest", "LightRain", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Black forest", "Clear", 0.2f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Swamp", "SwampRain Summer", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Swamp", "Swamp Summer", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mountain", "Twilight_Clear", 1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mountain", "Twilight_Snow", 1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Plains", "ThunderStorm", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Ocean", "Heath clear", 1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mistlands", "Heath clear", 0.5f));
				break;
			case Season.Fall:
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("ThunderStorm", "ThunderStorm Fall"));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Meadows", "DeepForest Mist", 0.2f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Meadows", "SwampRain Fall", 0.2f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Black forest", "LightRain", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Black forest", "SwampRain Fall", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Swamp", "ThunderStorm", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mountain", "Twilight_SnowStorm", 0.5f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Plains", "Rain", 0.4f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Plains", "ThunderStorm", 0.2f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Plains", "SwampRain Fall", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Ocean", "SwampRain Fall", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Ocean", "DeepForest Mist", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mistlands", "SwampRain Fall", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mistlands", "DeepForest Mist", 0.1f));
				break;
			case Season.Winter:
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Rain", "Rain Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("LightRain", "LightRain Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("ThunderStorm", "ThunderStorm Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Clear", "Clear Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Misty", "Misty Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("DeepForest Mist", "DeepForest Mist Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("SwampRain", "SwampRain Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Mistlands_clear", "Mistlands_clear Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Mistlands_rain", "Mistlands_rain Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Mistlands_thunder", "Mistlands_thunder Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Heath clear", "Heath clear Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("Snow", "Snow Winter"));
				seasonEnvironmentRules.Replace.Add(new EnvironmentReplace("SnowStorm", "SnowStorm Winter"));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Meadows", "Snow", 1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Black forest", "Snow", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mountain", "Twilight_Snow", 1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mountain", "Twilight_SnowStorm", 1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Plains", "Snow", 0.5f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Plains", "Twilight_SnowStorm", 0.3f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Ocean", "Darklands_dark Winter", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mistlands", "Twilight_Snow", 0.1f));
				seasonEnvironmentRules.Add.Add(new EnvironmentAdd("Mistlands", "Twilight_SnowStorm", 0.1f));
				seasonEnvironmentRules.Remove.Add(new EnvironmentRemove("Meadows", "Rain Winter"));
				seasonEnvironmentRules.Remove.Add(new EnvironmentRemove("Meadows", "LightRain Winter"));
				seasonEnvironmentRules.Remove.Add(new EnvironmentRemove("Meadows", "ThunderStorm Winter"));
				break;
			default:
				throw new ArgumentOutOfRangeException("season");
			case Season.Spring:
				break;
			}
			return seasonEnvironmentRules;
		}
	}
	public static class EnvironmentRules
	{
		public const string TempestPrefix = "Tempest_";

		public static bool IsForeign(string? environment)
		{
			return environment?.StartsWith("Tempest_", StringComparison.Ordinal) ?? false;
		}

		public static List<EnvironmentWeight> Apply(SeasonEnvironmentRules rules, string setupName, string enumName, IEnumerable<EnvironmentWeight> baseline, Func<string, bool> exists, Action<string>? onSkipped = null)
		{
			if (rules == null)
			{
				throw new ArgumentNullException("rules");
			}
			if (baseline == null)
			{
				throw new ArgumentNullException("baseline");
			}
			if (exists == null)
			{
				throw new ArgumentNullException("exists");
			}
			List<EnvironmentWeight> list = (from w in baseline
				where w != null
				select new EnvironmentWeight(w.Name, w.Weight, w.Source)).ToList();
			foreach (EnvironmentAdd item in rules.Add)
			{
				if (item != null && !string.IsNullOrWhiteSpace(item.Environment) && !IsForeign(item.Environment) && BiomeMatches(item.Biome, setupName, enumName))
				{
					if (!exists(item.Environment))
					{
						onSkipped?.Invoke(item.Environment);
					}
					else
					{
						list.Add(new EnvironmentWeight(item.Environment, item.Weight));
					}
				}
			}
			foreach (EnvironmentReplace item2 in rules.Replace)
			{
				if (item2 == null || string.IsNullOrWhiteSpace(item2.Environment) || string.IsNullOrWhiteSpace(item2.ReplaceTo) || IsForeign(item2.Environment) || IsForeign(item2.ReplaceTo))
				{
					continue;
				}
				bool flag = false;
				for (int num = 0; num < list.Count; num++)
				{
					if (!string.Equals(list[num].Name, item2.Environment, StringComparison.Ordinal))
					{
						continue;
					}
					if (!exists(item2.ReplaceTo))
					{
						if (!flag)
						{
							onSkipped?.Invoke(item2.ReplaceTo);
						}
						flag = true;
					}
					else
					{
						list[num] = new EnvironmentWeight(item2.ReplaceTo, list[num].Weight);
					}
				}
			}
			foreach (EnvironmentRemove remove in rules.Remove)
			{
				if (remove != null && !string.IsNullOrWhiteSpace(remove.Environment) && !IsForeign(remove.Environment) && BiomeMatches(remove.Biome, setupName, enumName))
				{
					list.RemoveAll((EnvironmentWeight w) => string.Equals(w.Name, remove.Environment, StringComparison.Ordinal));
				}
			}
			return list;
		}

		public static bool BiomeMatches(string? configuredName, string? setupName, string? enumName)
		{
			if (string.IsNullOrWhiteSpace(configuredName))
			{
				return false;
			}
			string a = Normalize(configuredName);
			if (!string.IsNullOrWhiteSpace(setupName) && string.Equals(a, Normalize(setupName), StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(enumName))
			{
				return string.Equals(a, Normalize(enumName), StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static string Normalize(string? name)
		{
			if (!string.IsNullOrWhiteSpace(name))
			{
				return name.Replace(" ", "").Replace("_", "").Replace("-", "");
			}
			return "";
		}
	}
	public readonly struct EnvironmentVariant
	{
		public string Name { get; }

		public string Source { get; }

		public byte Red { get; }

		public byte Green { get; }

		public byte Blue { get; }

		public EnvironmentVariant(string name, string source, byte red, byte green, byte blue)
		{
			Name = name;
			Source = source;
			Red = red;
			Green = green;
			Blue = blue;
		}
	}
	public static class EnvironmentVariants
	{
		private static readonly string[] Suffixes = new string[3] { " Summer", " Fall", " Winter" };

		public static IReadOnlyList<EnvironmentVariant> All { get; } = Build();

		public static bool IsVariant(string? name)
		{
			return Suffix(name) != null;
		}

		private static List<EnvironmentVariant> Build()
		{
			SortedDictionary<string, EnvironmentVariant> sortedDictionary = new SortedDictionary<string, EnvironmentVariant>(StringComparer.Ordinal);
			Season[] all = Seasons.All;
			for (int i = 0; i < all.Length; i++)
			{
				SeasonEnvironmentRules seasonEnvironmentRules = SeasonBiomeEnvironments.For(all[i]);
				foreach (EnvironmentReplace item in seasonEnvironmentRules.Replace)
				{
					Add(sortedDictionary, item.ReplaceTo);
				}
				foreach (EnvironmentAdd item2 in seasonEnvironmentRules.Add)
				{
					Add(sortedDictionary, item2.Environment);
				}
			}
			return sortedDictionary.Values.ToList();
		}

		private static void Add(SortedDictionary<string, EnvironmentVariant> map, string name)
		{
			string text = Suffix(name);
			if (text != null && !map.ContainsKey(name))
			{
				string source = name.Substring(0, name.Length - text.Length);
				if (name == "Swamp Summer")
				{
					source = "Darklands_dark";
				}
				byte red;
				byte green;
				byte blue;
				if (text == " Summer")
				{
					red = byte.MaxValue;
					green = 214;
					blue = 140;
				}
				else if (text == " Fall")
				{
					red = 196;
					green = 112;
					blue = 48;
				}
				else
				{
					red = 186;
					green = 206;
					blue = 214;
				}
				map.Add(name, new EnvironmentVariant(name, source, red, green, blue));
			}
		}

		private static string? Suffix(string? name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			string[] suffixes = Suffixes;
			foreach (string text in suffixes)
			{
				if (name.EndsWith(text, StringComparison.Ordinal) && name.Length > text.Length)
				{
					return text;
				}
			}
			return null;
		}
	}
	public static class SeasonSky
	{
		public const float ClearDaySun = 0.84f;

		public const float ClearDayAmbient = 0.88f;

		public const float ClearDayIntensity = 0.82f;

		public const float ClearDayFogSun = 0.9f;

		public static bool DimsLowlandClear(string? name)
		{
			if (!string.Equals(name, "Clear Winter", StringComparison.Ordinal))
			{
				return string.Equals(name, "Heath clear Winter", StringComparison.Ordinal);
			}
			return true;
		}

		public static float Scale(float value, float factor)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return value;
			}
			if (float.IsNaN(factor) || factor < 0f)
			{
				return value;
			}
			return value * factor;
		}
	}
}
namespace ExtraPotions.Solstice.Visuals
{
	public static class HeatMeter
	{
		public const float Partial = 0.4f;

		public const float FullSeconds = 8f;

		public const float ReliefSeconds = 4f;

		public const float LabelWide = 1280f;

		public const float LabelMinPixels = 8f;

		public const float LabelSizeAtWide = 14f;

		public static float LabelFontSize(float barHeight, float canvasScale, float screenWidth, float hudWidth)
		{
			float num = ((screenWidth > 1f) ? screenWidth : hudWidth);
			if (!float.IsNaN(num) && !float.IsInfinity(num) && num >= 1280f)
			{
				return 14f;
			}
			float num2 = canvasScale;
			if (float.IsNaN(num2) || num2 < 0.05f)
			{
				num2 = 1f;
			}
			if (14f * num2 >= 8f)
			{
				return 14f;
			}
			float num3 = 8f / num2;
			float num4 = barHeight - 2f;
			if (num4 >= 1f && num3 >= 1f && num3 <= num4)
			{
				return num3;
			}
			return 0f;
		}

		public static float Target(bool settingOn, bool seasonOverheats, bool shelteredOrCold, int warmClothes, bool coolingFood)
		{
			if (!settingOn || !seasonOverheats || shelteredOrCold || coolingFood || warmClothes <= 0)
			{
				return 0f;
			}
			if (warmClothes != 1)
			{
				return 1f;
			}
			return 0.4f;
		}

		public static float Advance(float current, float target, float seconds)
		{
			if (float.IsNaN(current) || float.IsInfinity(current) || current < 0f)
			{
				current = 0f;
			}
			if (current > 1f)
			{
				current = 1f;
			}
			if (float.IsNaN(target) || float.IsInfinity(target) || target < 0f)
			{
				target = 0f;
			}
			if (target > 1f)
			{
				target = 1f;
			}
			if (float.IsNaN(seconds) || float.IsInfinity(seconds) || seconds <= 0f || current == target)
			{
				return current;
			}
			float num = ((target > current) ? 0.125f : 0.25f);
			float num2 = seconds * num;
			if (num2 > 1f)
			{
				num2 = 1f;
			}
			float num3 = ((target > current) ? (current + num2) : (current - num2));
			if (target > current)
			{
				if (!(num3 > target))
				{
					return num3;
				}
				return target;
			}
			if (!(num3 < target))
			{
				return num3;
			}
			return target;
		}
	}
	public static class HeatMeterLayout
	{
		public const float Width = 168f;

		public const float Height = 18f;

		public static HudBox Union(HudBox a, HudBox b)
		{
			if (!a.Shown)
			{
				return b;
			}
			if (!b.Shown)
			{
				return a;
			}
			float num = ((a.Left < b.Left) ? a.Left : b.Left);
			float num2 = ((a.Top < b.Top) ? a.Top : b.Top);
			float num3 = ((a.Right > b.Right) ? a.Right : b.Right);
			float num4 = ((a.Bottom > b.Bottom) ? a.Bottom : b.Bottom);
			return new HudBox(num, num2, num3 - num, num4 - num2);
		}

		public static HudBox Place(float parentWidth, float parentHeight, HudBox above, float occupiedBottom, HudBox status, HudBox notices, HudBox hotbar)
		{
			float num = 168f;
			float num2 = 18f;
			if (parentWidth > 0f && num > parentWidth)
			{
				num = parentWidth;
			}
			float left = SeasonHudLayout.Left(parentWidth, num);
			float num3 = 14f;
			if (above.Shown && num3 < above.Bottom + 6f)
			{
				num3 = above.Bottom + 6f;
			}
			if (occupiedBottom >= 0f && num3 < occupiedBottom + 6f)
			{
				num3 = occupiedBottom + 6f;
			}
			if (Hits(left, num3, num, num2, status))
			{
				num3 = status.Bottom + 6f;
			}
			Shift(ref left, num3, num, num2, notices, parentWidth);
			if (Hits(left, num3, num, num2, hotbar))
			{
				float num4 = hotbar.Top - 6f - num2;
				if (num4 >= 0f && !Hits(left, num4, num, num2, hotbar) && !Hits(left, num4, num, num2, above) && !Hits(left, num4, num, num2, status))
				{
					num3 = num4;
				}
			}
			if (parentHeight > 0f && num3 + num2 > parentHeight)
			{
				num3 = parentHeight - num2;
			}
			if (num3 < 0f)
			{
				num3 = 0f;
			}
			if (occupiedBottom >= 0f && num3 < occupiedBottom)
			{
				return default(HudBox);
			}
			if (Hits(left, num3, num, num2, above) || Hits(left, num3, num, num2, status) || Hits(left, num3, num, num2, notices) || Hits(left, num3, num, num2, hotbar))
			{
				return default(HudBox);
			}
			return new HudBox(left, num3, num, num2);
		}

		private static void Shift(ref float left, float top, float width, float height, HudBox block, float parentWidth)
		{
			if (Hits(left, top, width, height, block))
			{
				float num = block.Left - 6f - width;
				float num2 = block.Right + 6f;
				bool flag = num >= 0f && !Hits(num, top, width, height, block);
				if ((parentWidth <= 0f || num2 + width <= parentWidth) && !Hits(num2, top, width, height, block) && (!flag || block.Left < left))
				{
					left = num2;
				}
				else if (flag)
				{
					left = num;
				}
			}
		}

		private static bool Hits(float left, float top, float width, float height, HudBox other)
		{
			return SeasonHudLayout.Overlaps(left, top, width, height, other);
		}
	}
	public static class SeasonGround
	{
		public const int Meadows = 1;

		public const int Swamp = 2;

		public const int BlackForest = 8;

		public const int Plains = 16;

		public const int SnowBiomes = 27;

		public const float MaskCap = 0.8f;

		public const int FrostSteps = 4;

		public const double PixelBudgetMs = 2.0;

		public const int ChunksPerFrame = 3;

		public const double ChunkSliceMs = 12.0;

		public static bool Paints(int biome)
		{
			if (biome != 1 && biome != 2 && biome != 8)
			{
				return biome == 16;
			}
			return true;
		}

		public static void Paint(int biome, ref byte r, ref byte g, ref byte b, ref byte a, float amount)
		{
			if (Paints(biome) && !float.IsNaN(amount) && !(amount <= 0f))
			{
				if (amount > 0.8f)
				{
					amount = 0.8f;
				}
				float num = 1f - amount;
				r = Unit((float)(int)r * num);
				g = Unit((float)(int)g * num + 255f * amount);
				b = Unit((float)(int)b * num);
				a = Unit((float)(int)a * num);
			}
		}

		public static bool IsGrass(string name)
		{
			if (!string.IsNullOrEmpty(name))
			{
				return name.IndexOf("grass", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		public static bool HideBloom(string name, float amount)
		{
			if (string.IsNullOrEmpty(name) || float.IsNaN(amount) || amount < 0.2f)
			{
				return false;
			}
			if (name.IndexOf("flower", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("bloom", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		public static int GrassCount(int original, float amount)
		{
			if (original <= 0 || float.IsNaN(amount) || amount <= 0f)
			{
				return original;
			}
			if (amount > 1f)
			{
				amount = 1f;
			}
			int num = (int)Math.Round((double)original * (1.0 - 0.55 * (double)amount));
			if (num < 1)
			{
				num = 1;
			}
			if (num <= original)
			{
				return num;
			}
			return original;
		}

		public static float GrassScale(float original, float amount)
		{
			if (float.IsNaN(original) || float.IsNaN(amount) || amount <= 0f)
			{
				return original;
			}
			if (amount > 1f)
			{
				amount = 1f;
			}
			return original * (1f - 0.45f * amount);
		}

		public static int FrostStep(float amount)
		{
			if (float.IsNaN(amount) || amount <= 0f)
			{
				return 0;
			}
			if (amount > 1f)
			{
				amount = 1f;
			}
			int num = (int)Math.Ceiling((double)(amount * 4f) - 0.0001);
			if (num < 1)
			{
				num = 1;
			}
			if (num > 4)
			{
				num = 4;
			}
			return num;
		}

		public static float FrostAmount(int step)
		{
			if (step <= 0)
			{
				return 0f;
			}
			if (step > 4)
			{
				step = 4;
			}
			return (float)step / 4f;
		}

		public static int NextChunk(int doneThisFrame, double elapsedMs, int remaining)
		{
			if (remaining <= 0 || doneThisFrame >= 3)
			{
				return 0;
			}
			if (doneThisFrame > 0 && elapsedMs >= 12.0)
			{
				return 0;
			}
			return 1;
		}

		public static void Frost(byte[] rgba, float amount, bool leaves)
		{
			if (rgba == null || rgba.Length < 4 || float.IsNaN(amount) || amount <= 0f)
			{
				return;
			}
			if (amount > 1f)
			{
				amount = 1f;
			}
			int num = rgba.Length - rgba.Length % 4;
			for (int i = 0; i < num; i += 4)
			{
				byte b = rgba[i + 3];
				if (b != 0)
				{
					float r = (float)(int)rgba[i] / 255f;
					float g = (float)(int)rgba[i + 1] / 255f;
					float b2 = (float)(int)rgba[i + 2] / 255f;
					if (leaves)
					{
						DustLeaf(ref r, ref g, ref b2, amount);
					}
					else
					{
						Whiten(ref r, ref g, ref b2, amount * 0.9f, 0.91f, 0.95f, 0.98f);
					}
					rgba[i] = Unit(r * 255f);
					rgba[i + 1] = Unit(g * 255f);
					rgba[i + 2] = Unit(b2 * 255f);
					rgba[i + 3] = b;
				}
			}
		}

		private static void Whiten(ref float r, ref float g, ref float b, float blend, float targetR, float targetG, float targetB)
		{
			r += (targetR - r) * blend;
			g += (targetG - g) * blend;
			b += (targetB - b) * blend;
		}

		private static void DustLeaf(ref float r, ref float g, ref float b, float amount)
		{
			float num = ((r > g) ? r : g);
			if (b > num)
			{
				num = b;
			}
			float num2 = ((r < g) ? r : g);
			if (b < num2)
			{
				num2 = b;
			}
			float num3 = ((num <= 0.001f) ? 0f : ((num - num2) / num));
			float num4 = 0.2126f * r + 0.7152f * g + 0.0722f * b;
			if (g >= r + 0.05f && g >= b + 0.02f && num3 >= 0.28f && num4 >= 0.22f && g >= 0.25f)
			{
				float num5 = amount * 0.48f;
				r += (0.93f - r) * num5;
				g += (0.96f - g) * num5;
				b += (0.9f - b) * num5;
				return;
			}
			float num6 = amount * 0.1f;
			if (num4 < 0.18f)
			{
				num6 *= 0.35f;
			}
			r += (0.78f - r) * num6;
			g += (0.74f - g) * num6;
			b += (0.68f - b) * num6;
		}

		private static byte Unit(float value)
		{
			if (value <= 0f)
			{
				return 0;
			}
			if (value >= 255f)
			{
				return byte.MaxValue;
			}
			return (byte)Math.Round(value);
		}
	}
	public readonly struct HudBox
	{
		public float Left { get; }

		public float Top { get; }

		public float Width { get; }

		public float Height { get; }

		public float Right => Left + Width;

		public float Bottom => Top + Height;

		public bool Shown
		{
			get
			{
				if (Width > 0f)
				{
					return Height > 0f;
				}
				return false;
			}
		}

		public HudBox(float left, float top, float width, float height)
		{
			Left = left;
			Top = top;
			Width = width;
			Height = height;
		}
	}
	public static class SeasonHudLayout
	{
		public const float Gap = 6f;

		public const float TopGap = 14f;

		public const float ChipWidth = 188f;

		public const float ChipHeight = 24f;

		public static float Left(float parentWidth, float chipWidth)
		{
			if (parentWidth > 0f && chipWidth > parentWidth)
			{
				chipWidth = parentWidth;
			}
			if (!(parentWidth > chipWidth))
			{
				return 0f;
			}
			return (parentWidth - chipWidth) * 0.5f;
		}

		public static HudBox Place(float parentWidth, float chipWidth, float chipHeight, float occupiedBottom, HudBox status)
		{
			if (chipWidth < 1f)
			{
				chipWidth = 188f;
			}
			if (chipHeight < 1f)
			{
				chipHeight = 24f;
			}
			if (parentWidth > 0f && chipWidth > parentWidth)
			{
				chipWidth = parentWidth;
			}
			float left = Left(parentWidth, chipWidth);
			float num = 14f;
			if (occupiedBottom >= 0f && num < occupiedBottom + 6f)
			{
				num = occupiedBottom + 6f;
			}
			if (Overlaps(left, num, chipWidth, chipHeight, status))
			{
				num = status.Bottom + 6f;
			}
			return new HudBox(left, num, chipWidth, chipHeight);
		}

		public static bool Overlaps(float left, float top, float width, float height, HudBox other)
		{
			if (!other.Shown || width <= 0f || height <= 0f)
			{
				return false;
			}
			if (left < other.Right && left + width > other.Left && top < other.Bottom)
			{
				return top + height > other.Top;
			}
			return false;
		}
	}
	public static class SeasonIcon
	{
		public const int Size = 32;

		public const byte AmberR = 217;

		public const byte AmberG = 148;

		public const byte AmberB = 54;

		public const byte BrassR = 168;

		public const byte BrassG = 121;

		public const byte BrassB = 56;

		public const byte CreamR = 226;

		public const byte CreamG = 208;

		public const byte CreamB = 168;

		public const byte CharcoalR = 38;

		public const byte CharcoalG = 37;

		public const byte CharcoalB = 34;

		public static byte[] DrawHeat()
		{
			byte[] array = new byte[4096];
			Flame(array);
			Outline(array);
			return array;
		}

		public static byte[] Draw(Season season)
		{
			byte[] array = new byte[4096];
			switch (season)
			{
			case Season.Spring:
				Sprout(array);
				break;
			case Season.Summer:
				Sun(array);
				break;
			case Season.Fall:
				Leaf(array);
				break;
			default:
				Crystal(array);
				break;
			}
			Outline(array);
			return array;
		}

		public static bool IsPalette(byte r, byte g, byte b)
		{
			if ((r != 217 || g != 148 || b != 54) && (r != 168 || g != 121 || b != 56) && (r != 226 || g != 208 || b != 168))
			{
				if (r == 38 && g == 37)
				{
					return b == 34;
				}
				return false;
			}
			return true;
		}

		private static void Flame(byte[] pixels)
		{
			for (int i = 4; i <= 27; i++)
			{
				int num = FlameHalf(i - 4);
				int num2 = ((i >= 18) ? 17 : 16);
				for (int j = num2 - num; j <= num2 + num; j++)
				{
					int num3 = j - num2;
					if (num3 < 0)
					{
						num3 = -num3;
					}
					bool flag = i >= 6 && i <= 16 && num3 <= ((i > 12) ? 1 : 2);
					if (flag && i <= 11)
					{
						Plot(pixels, j, i, 226, 208, 168);
					}
					else if (flag)
					{
						Plot(pixels, j, i, 168, 121, 56);
					}
					else
					{
						Plot(pixels, j, i, 217, 148, 54);
					}
				}
			}
			for (int k = 5; k <= 11; k++)
			{
				Plot(pixels, 11, k, 217, 148, 54);
				Plot(pixels, 10, k, 168, 121, 56);
			}
		}

		private static int FlameHalf(int rise)
		{
			return rise switch
			{
				0 => 3, 
				1 => 4, 
				2 => 5, 
				3 => 6, 
				4 => 7, 
				5 => 7, 
				6 => 6, 
				7 => 6, 
				8 => 5, 
				9 => 5, 
				10 => 4, 
				11 => 4, 
				12 => 3, 
				13 => 3, 
				14 => 3, 
				15 => 2, 
				16 => 2, 
				17 => 2, 
				18 => 2, 
				19 => 1, 
				20 => 1, 
				21 => 1, 
				22 => 1, 
				_ => 0, 
			};
		}

		private static void Sun(byte[] pixels)
		{
			int[] array = new int[8] { 1, 1, 0, -1, -1, -1, 0, 1 };
			int[] array2 = new int[8] { 0, 1, 1, 1, 0, -1, -1, -1 };
			for (int i = 0; i < 8; i++)
			{
				for (int j = 9; j <= 13; j++)
				{
					Plot(pixels, 16 + array[i] * j, 16 + array2[i] * j, 168, 121, 56);
				}
			}
			Disc(pixels, 16, 16, 7, 217, 148, 54);
			Disc(pixels, 16, 16, 3, 226, 208, 168);
		}

		private static void Sprout(byte[] pixels)
		{
			for (int i = 2; i <= 14; i++)
			{
				Plot(pixels, 15, i, 226, 208, 168);
				Plot(pixels, 16, i, 226, 208, 168);
			}
			Ellipse(pixels, 9, 16, 6, 4, 217, 148, 54);
			Ellipse(pixels, 22, 17, 6, 4, 168, 121, 56);
			Disc(pixels, 16, 21, 2, 226, 208, 168);
		}

		private static void Leaf(byte[] pixels)
		{
			for (int i = 8; i <= 26; i++)
			{
				int num = 9 - Abs(i - 18) * 9 / 10;
				if (num < 1)
				{
					num = 1;
				}
				for (int j = 16 - num; j <= 16 + num; j++)
				{
					Plot(pixels, j, i, 217, 148, 54);
				}
			}
			for (int k = 8; k <= 26; k++)
			{
				Plot(pixels, 16, k, 226, 208, 168);
			}
			for (int l = 2; l <= 8; l++)
			{
				Plot(pixels, 16, l, 168, 121, 56);
			}
		}

		private static void Crystal(byte[] pixels)
		{
			for (int i = 4; i <= 28; i++)
			{
				Plot(pixels, i, 16, 226, 208, 168);
				Plot(pixels, 16, i, 226, 208, 168);
			}
			for (int j = 1; j <= 8; j++)
			{
				Plot(pixels, 16 + j, 16 + j, 168, 121, 56);
				Plot(pixels, 16 - j, 16 + j, 168, 121, 56);
				Plot(pixels, 16 + j, 16 - j, 168, 121, 56);
				Plot(pixels, 16 - j, 16 - j, 168, 121, 56);
			}
			Disc(pixels, 16, 16, 2, 168, 121, 56);
		}

		private static void Outline(byte[] pixels)
		{
			byte[] array = new byte[pixels.Length];
			Buffer.BlockCopy(pixels, 0, array, 0, pixels.Length);
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					if (Alpha(array, j, i) == 0 && (Alpha(array, j - 1, i) != 0 || Alpha(array, j + 1, i) != 0 || Alpha(array, j, i - 1) != 0 || Alpha(array, j, i + 1) != 0))
					{
						Plot(pixels, j, i, 38, 37, 34);
					}
				}
			}
		}

		private static int Alpha(byte[] pixels, int x, int y)
		{
			if ((uint)x >= 32u || (uint)y >= 32u)
			{
				return 0;
			}
			return pixels[(y * 32 + x) * 4 + 3];
		}

		private static void Disc(byte[] pixels, int cx, int cy, int radius, byte r, byte g, byte b)
		{
			int num = radius * radius;
			for (int i = cy - radius; i <= cy + radius; i++)
			{
				for (int j = cx - radius; j <= cx + radius; j++)
				{
					int num2 = j - cx;
					int num3 = i - cy;
					if (num2 * num2 + num3 * num3 <= num)
					{
						Plot(pixels, j, i, r, g, b);
					}
				}
			}
		}

		private static void Ellipse(byte[] pixels, int cx, int cy, int rx, int ry, byte r, byte g, byte b)
		{
			if (rx < 1 || ry < 1)
			{
				return;
			}
			int num = rx * rx;
			int num2 = ry * ry;
			for (int i = cy - ry; i <= cy + ry; i++)
			{
				for (int j = cx - rx; j <= cx + rx; j++)
				{
					int num3 = j - cx;
					int num4 = i - cy;
					if (num3 * num3 * num2 + num4 * num4 * num <= num * num2)
					{
						Plot(pixels, j, i, r, g, b);
					}
				}
			}
		}

		private static void Plot(byte[] pixels, int x, int y, byte r, byte g, byte b)
		{
			if ((uint)x < 32u && (uint)y < 32u)
			{
				int num = (y * 32 + x) * 4;
				pixels[num] = r;
				pixels[num + 1] = g;
				pixels[num + 2] = b;
				pixels[num + 3] = byte.MaxValue;
			}
		}

		private static int Abs(int value)
		{
			if (value >= 0)
			{
				return value;
			}
			return -value;
		}
	}
	public static class SeasonRebuild
	{
		public static bool Text(bool sameObject, string? text, string? cached, int day, int cachedDay, int length, int cachedLength)
		{
			if (!sameObject)
			{
				return true;
			}
			if (!string.Equals(text, cached, StringComparison.Ordinal))
			{
				return true;
			}
			if (day == cachedDay)
			{
				return length != cachedLength;
			}
			return true;
		}
	}
	public enum TintChannel
	{
		Grass,
		Leaf,
		Terrain,
		Map,
		ShallowWater
	}
	public readonly struct Rgb
	{
		public float R { get; }

		public float G { get; }

		public float B { get; }

		public Rgb(float r, float g, float b)
		{
			R = r;
			G = g;
			B = b;
		}

		public static float Clamp(float value)
		{
			if (!(value < 0f))
			{
				if (!(value > 1f))
				{
					return value;
				}
				return 1f;
			}
			return 0f;
		}

		public Rgb Clamped()
		{
			return new Rgb(Clamp(R), Clamp(G), Clamp(B));
		}
	}
	public static class SeasonTint
	{
		public const float SnowShowsFrom = 0.25f;

		public const float IceBlend = 0.55f;

		public const float SurfaceIceBlend = 0.34f;

		public const float FoamIceBlend = 0.3f;

		public const float RippleCalm = 1.45f;

		public const float RippleCalmCap = 12f;

		public static readonly Rgb Ice = new Rgb(0.45f, 0.64f, 0.8f);

		public static readonly Rgb SnowWhite = new Rgb(0.93f, 0.95f, 0.97f);

		public static Rgb Apply(TintChannel channel, Season season, Rgb color, bool frozen)
		{
			if (channel == TintChannel.ShallowWater)
			{
				return Freeze(color, frozen);
			}
			Rgb color2 = Multiply(color, Multiplier(channel, season));
			if (season != Season.Winter)
			{
				return color2.Clamped();
			}
			return Desaturate(color2, WinterFade(channel)).Clamped();
		}

		public static Rgb Multiplier(TintChannel channel, Season season)
		{
			return channel switch
			{
				TintChannel.Grass => Grass(season), 
				TintChannel.Leaf => Leaf(season), 
				TintChannel.Terrain => Terrain(season), 
				TintChannel.Map => Map(season), 
				_ => new Rgb(1f, 1f, 1f), 
			};
		}

		public static float WinterFade(TintChannel channel)
		{
			return channel switch
			{
				TintChannel.Grass => 0.9f, 
				TintChannel.Leaf => 0.94f, 
				TintChannel.Terrain => 0.4f, 
				TintChannel.Map => 0.35f, 
				_ => 0f, 
			};
		}

		public static Rgb Multiply(Rgb color, Rgb multiplier)
		{
			return new Rgb(color.R * multiplier.R, color.G * multiplier.G, color.B * multiplier.B);
		}

		public static Rgb Desaturate(Rgb color, float amount)
		{
			if (amount <= 0f)
			{
				return color;
			}
			if (amount > 1f)
			{
				amount = 1f;
			}
			float num = 0.2126f * color.R + 0.7152f * color.G + 0.0722f * color.B;
			float num2 = 1f - amount;
			return new Rgb(color.R * num2 + num * amount, color.G * num2 + num * amount, color.B * num2 + num * amount);
		}

		public static float Saturation(Rgb color)
		{
			float num = ((color.R > color.G) ? color.R : color.G);
			if (color.B > num)
			{
				num = color.B;
			}
			float num2 = ((color.R < color.G) ? color.R : color.G);
			if (color.B < num2)
			{
				num2 = color.B;
			}
			if (!(num <= 0f))
			{
				return (num - num2) / num;
			}
			return 0f;
		}

		public static Rgb Freeze(Rgb color, bool frozen)
		{
			return FreezeAmount(color, frozen, 0.55f);
		}

		public static Rgb FreezeAmount(Rgb color, bool frozen, float blend)
		{
			if (!frozen || blend <= 0f)
			{
				return color;
			}
			if (blend > 1f)
			{
				blend = 1f;
			}
			return new Rgb(color.R + (Ice.R - color.R) * blend, color.G + (Ice.G - color.G) * blend, color.B + (Ice.B - color.B) * blend).Clamped();
		}

		public static float CalmRipple(float original, bool frozen)
		{
			if (!frozen || float.IsNaN(original) || float.IsInfinity(original) || original < 0f)
			{
				return original;
			}
			float num = original * 1.45f;
			float num2 = original + 12f;
			if (!(num > num2))
			{
				return num;
			}
			return num2;
		}

		public static Rgb Whiten(Rgb color, float cover)
		{
			float num = SnowLevel(cover);
			if (num <= 0f)
			{
				return color;
			}
			return new Rgb(color.R + (SnowWhite.R - color.R) * num, color.G + (SnowWhite.G - color.G) * num, color.B + (SnowWhite.B - color.B) * num).Clamped();
		}

		public static float SnowLevel(float cover)
		{
			if (float.IsNaN(cover) || cover <= 0.25f)
			{
				return 0f;
			}
			float num = (cover - 0.25f) / 0.75f;
			if (num < 0f)
			{
				return 0f;
			}
			if (!(num > 1f))
			{
				return num;
			}
			return 1f;
		}

		public static float SnowApply(float original, float cover)
		{
			if (float.IsNaN(original))
			{
				original = 0f;
			}
			float num = SnowLevel(cover);
			if (!(original > num))
			{
				return num;
			}
			return original;
		}

		private static Rgb Grass(Season season)
		{
			return season switch
			{
				Season.Spring => new Rgb(0.9f, 1.12f, 0.86f), 
				Season.Summer => new Rgb(0.82f, 1f, 0.7f), 
				Season.Fall => new Rgb(1.15f, 0.92f, 0.58f), 
				_ => new Rgb(0.7f, 0.74f, 1.08f), 
			};
		}

		private static Rgb Leaf(Season season)
		{
			return season switch
			{
				Season.Spring => new Rgb(0.86f, 1.16f, 0.78f), 
				Season.Summer => new Rgb(0.8f, 1.02f, 0.68f), 
				Season.Fall => new Rgb(1.4f, 0.58f, 0.26f), 
				_ => new Rgb(0.72f, 0.76f, 1.06f), 
			};
		}

		private static Rgb Terrain(Season season)
		{
			return season switch
			{
				Season.Spring => new Rgb(0.97f, 1.05f, 0.95f), 
				Season.Summer => new Rgb(0.95f, 1.02f, 0.9f), 
				Season.Fall => new Rgb(1.08f, 0.97f, 0.84f), 
				_ => new Rgb(0.96f, 0.98f, 1.02f), 
			};
		}

		private static Rgb Map(Season season)
		{
			return season switch
			{
				Season.Spring => new Rgb(0.93f, 1.05f, 0.92f), 
				Season.Summer => new Rgb(0.9f, 1.02f, 0.86f), 
				Season.Fall => new Rgb(1.1f, 0.95f, 0.8f), 
				_ => new Rgb(0.88f, 0.92f, 1f), 
			};
		}
	}
	public static class SeasonShader
	{
		public const string Color = "_Color";

		public const string SnowLevel = "_SnowLevel";

		public const string Shallow = "_ColorBottomShallow";

		public const string Top = "_ColorTop";

		public const string Foam = "_FoamColor";

		public const string Ripple = "_RippleDistance";
	}
	[Flags]
	public enum VisualTarget
	{
		None = 0,
		Grass = 1,
		Leaf = 2,
		Terrain = 4,
		Snow = 8,
		ShallowWater = 0x10,
		WaterTop = 0x20,
		WaterFoam = 0x40,
		WaterRipple = 0x80,
		WaterSurface = 0x100
	}
	public static class SeasonVisualSelection
	{
		public static VisualTarget Select(string? shaderName, string? materialName, bool color, bool snowLevel, bool shallow, bool foam = false, bool ripple = false, bool top = false)
		{
			string text = shaderName ?? "";
			string text2 = materialName ?? "";
			if (text.Length == 0 && text2.Length == 0)
			{
				return VisualTarget.None;
			}
			if (Excluded(text))
			{
				return VisualTarget.None;
			}
			VisualTarget visualTarget = VisualTarget.None;
			if (Has(text, "water"))
			{
				if (shallow)
				{
					visualTarget |= VisualTarget.ShallowWater;
				}
				if (top)
				{
					visualTarget |= VisualTarget.WaterTop;
				}
				if (foam)
				{
					visualTarget |= VisualTarget.WaterFoam;
				}
				if (ripple)
				{
					visualTarget |= VisualTarget.WaterRipple;
				}
				return visualTarget;
			}
			if (snowLevel)
			{
				visualTarget |= VisualTarget.Snow;
			}
			if (!color)
			{
				return visualTarget;
			}
			if (Has(text, "grass"))
			{
				visualTarget |= VisualTarget.Grass;
			}
			else if (Has(text, "vegetation") || Has(text, "foliage") || Has(text, "leaf"))
			{
				visualTarget |= VisualTarget.Leaf;
			}
			else if (Has(text, "terrain") || Has(text, "heightmap"))
			{
				visualTarget |= VisualTarget.Terrain;
			}
			else if (Has(text2, "grass"))
			{
				visualTarget |= VisualTarget.Grass;
			}
			else if (Has(text2, "leaf") || Has(text2, "bush") || Has(text2, "shrub") || Has(text2, "foliage"))
			{
				visualTarget |= VisualTarget.Leaf;
			}
			return visualTarget;
		}

		public static bool BarkOnly(string? name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (!Has(name, "bark") && !Has(name, "trunk") && !Has(name, "log"))
			{
				return Has(name, "stem");
			}
			return true;
		}

		public static bool FrostTexture(string? shaderName, string? materialName, out bool leaves)
		{
			return FrostTexture(shaderName, materialName, null, out leaves);
		}

		public static bool FrostTexture(string? shaderName, string? materialName, string? textureName, out bool leaves)
		{
			leaves = false;
			string text = shaderName ?? "";
			string text2 = materialName ?? "";
			if (text.Length == 0 && text2.Length == 0 && string.IsNullOrEmpty(textureName))
			{
				return false;
			}
			if (Excluded(text))
			{
				return false;
			}
			if (Has(text, "water") || Has(text, "terrain") || Has(text, "heightmap"))
			{
				return false;
			}
			if (BarkOnly(text2) || BarkOnly(text))
			{
				return false;
			}
			if (Has(text, "grass"))
			{
				leaves = GroundClutter(text2) || GroundClutter(textureName);
				return true;
			}
			if (Has(text, "vegetation") || Has(text, "foliage") || Has(text, "leaf"))
			{
				leaves = true;
				return true;
			}
			return false;
		}

		public static bool GroundClutter(string? name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (!Has(name, "groundcover") && !Has(name, "ormbunke") && !Has(name, "fern") && !Has(name, "shrub") && !Has(name, "bush") && !Has(name, "waterlil") && !Has(name, "clutter") && !Has(name, "grasscross_forest"))
			{
				return Has(name, "vass");
			}
			return true;
		}

		private static bool Excluded(string shader)
		{
			if (!Has(shader, "creature") && !Has(shader, "character") && !Has(shader, "player") && !Has(shader, "ui/") && !Has(shader, "gui/") && !Has(shader, "textmesh") && !Has(shader, "particle") && !Has(shader, "sprite") && !Has(shader, "font"))
			{
				return Has(shader, "decal");
			}
			return true;
		}

		private static bool Has(string text, string part)
		{
			return text.IndexOf(part, StringComparison.OrdinalIgnoreCase) >= 0;
		}
	}
}
namespace ExtraPotions.Solstice.Localization
{
	public readonly struct TextKey
	{
		public string Key { get; }

		public int Arguments { get; }

		public TextKey(string key, int arguments)
		{
			Key = key;
			Arguments = arguments;
		}
	}
	public static class SolsticeTextKeys
	{
		public const string BlockedSetByServer = "blocked_set_by_server";

		public const string BlockedVanillaServer = "blocked_vanilla_server";

		public const string BlockedProductDisabled = "blocked_product_disabled";

		public const string BlockedNotAdmin = "blocked_not_admin";

		public const string BlockedAuthorityPending = "blocked_authority_pending";

		public const string OffNoCrucible = "off_no_crucible";

		public const string OffNoSolstice = "off_no_solstice";

		public const string SeasonStarted = "season_started";

		public const string CommandStatus = "cmd_status";

		public const string CommandStatusOverride = "cmd_status_override";

		public const string CommandInactive = "cmd_inactive";

		public const string CommandHelp = "cmd_help";

		public const string CommandWaiting = "cmd_waiting";

		public const string PlantFrostResistant = "plant_frost_resistant";

		public const string PlantHeatProtected = "plant_heat_protected";

		public const string PlantSurvivedWinter = "plant_survived_winter";

		public const string PlantFreezing = "plant_freezing";

		public const string PlantWillPerish = "plant_will_perish";

		public const string PlantExposed = "plant_exposed";

		public const string StatusOverheat = "status_overheat";

		public const string StatusOverheatTip = "status_overheat_tip";

		public const string StatusSeasonTip = "status_season_tip";

		public const string HudSeason = "hud_season";

		public const string HudHeat = "hud_heat";

		public static IReadOnlyList<TextKey> All { get; } = Array.AsReadOnly(new TextKey[168]
		{
			new TextKey("step_aside_seasons", 1),
			new TextKey("off_no_crucible", 0),
			new TextKey("off_no_solstice", 0),
			new TextKey("blocked_set_by_server", 0),
			new TextKey("blocked_vanilla_server", 0),
			new TextKey("blocked_product_disabled", 0),
			new TextKey("blocked_not_admin", 0),
			new TextKey("blocked_authority_pending", 0),
			new TextKey("cheat_season_override", 0),
			new TextKey("season_spring", 0),
			new TextKey("season_summer", 0),
			new TextKey("season_fall", 0),
			new TextKey("season_winter", 0),
			new TextKey("season_started", 1),
			new TextKey("cmd_status", 3),
			new TextKey("cmd_status_override", 3),
			new TextKey("cmd_inactive", 0),
			new TextKey("cmd_help", 0),
			new TextKey("cmd_waiting", 0),
			new TextKey("plant_frost_resistant", 0),
			new TextKey("plant_heat_protected", 0),
			new TextKey("plant_survived_winter", 0),
			new TextKey("plant_freezing", 1),
			new TextKey("plant_will_perish", 0),
			new TextKey("plant_exposed", 0),
			new TextKey("status_overheat", 0),
			new TextKey("status_overheat_tip", 0),
			new TextKey("status_season_tip", 2),
			new TextKey("hud_season", 2),
			new TextKey("hud_heat", 0),
			new TextKey("cfg_visuals_heading", 0),
			new TextKey("cfg_visuals__world_tint_name", 0),
			new TextKey("cfg_visuals__world_tint_help", 0),
			new TextKey("cfg_visuals__snow_cover_name", 0),
			new TextKey("cfg_visuals__snow_cover_help", 0),
			new TextKey("cfg_visuals__frozen_water_name", 0),
			new TextKey("cfg_visuals__frozen_water_help", 0),
			new TextKey("cfg_visuals__minimap_tint_name", 0),
			new TextKey("cfg_visuals__minimap_tint_help", 0),
			new TextKey("cfg_visuals__season_indicator_name", 0),
			new TextKey("cfg_visuals__season_indicator_help", 0),
			new TextKey("cfg_visuals__season_icons_name", 0),
			new TextKey("cfg_visuals__season_icons_help", 0),
			new TextKey("cfg_visuals__heat_meter_name", 0),
			new TextKey("cfg_visuals__heat_meter_help", 0),
			new TextKey("cfg_music_heading", 0),
			new TextKey("cfg_music__seasonal_music_name", 0),
			new TextKey("cfg_music__seasonal_music_help", 0),
			new TextKey("cfg_general_heading", 0),
			new TextKey("cfg_calendar_heading", 0),
			new TextKey("cfg_spring_heading", 0),
			new TextKey("cfg_summer_heading", 0),
			new TextKey("cfg_fall_heading", 0),
			new TextKey("cfg_winter_heading", 0),
			new TextKey("cfg_protection_heading", 0),
			new TextKey("cfg_climate_heading", 0),
			new TextKey("cfg_notices_heading", 0),
			new TextKey("cfg_cheats_heading", 0),
			new TextKey("cfg_general__enabled_name", 0),
			new TextKey("cfg_general__enabled_help", 0),
			new TextKey("cfg_protection__heat_protects_crops_name", 0),
			new TextKey("cfg_protection__heat_protects_crops_help", 0),
			new TextKey("cfg_protection__shield_generator_protects_name", 0),
			new TextKey("cfg_protection__shield_generator_protects_help", 0),
			new TextKey("cfg_protection__shield_generator_protects_in_winter_only_name", 0),
			new TextKey("cfg_protection__shield_generator_protects_in_winter_only_help", 0),
			new TextKey("cfg_protection__winter_hardy_crops_name", 0),
			new TextKey("cfg_protection__winter_hardy_crops_help", 0),
			new TextKey("cfg_protection__crops_perish_name", 0),
			new TextKey("cfg_protection__crops_perish_help", 0),
			new TextKey("cfg_protection__perish_from_day_name", 0),
			new TextKey("cfg_protection__perish_from_day_help", 0),
			new TextKey("cfg_protection__freeze_seconds_name", 0),
			new TextKey("cfg_protection__freeze_seconds_help", 0),
			new TextKey("cfg_protection__winter_harvest_chance_name", 0),
			new TextKey("cfg_protection__winter_harvest_chance_help", 0),
			new TextKey("cfg_protection__crops_to_control_name", 0),
			new TextKey("cfg_protection__crops_to_control_help", 0),
			new TextKey("cfg_climate__season_status_name", 0),
			new TextKey("cfg_climate__season_status_help", 0),
			new TextKey("cfg_climate__warm_clothes_overheat_name", 0),
			new TextKey("cfg_climate__warm_clothes_overheat_help", 0),
			new TextKey("cfg_climate__cooling_foods_name", 0),
			new TextKey("cfg_climate__cooling_foods_help", 0),
			new TextKey("cfg_notices__season_message_name", 0),
			new TextKey("cfg_notices__season_message_help", 0),
			new TextKey("cfg_cheats__season_override_name", 0),
			new TextKey("cfg_cheats__season_override_help", 0),
			new TextKey("cfg_calendar__days_in_spring_name", 0),
			new TextKey("cfg_calendar__days_in_spring_help", 0),
			new TextKey("cfg_spring__plants_growth_multiplier_name", 0),
			new TextKey("cfg_spring__plants_growth_multiplier_help", 0),
			new TextKey("cfg_spring__beehive_production_multiplier_name", 0),
			new TextKey("cfg_spring__beehive_production_multiplier_help", 0),
			new TextKey("cfg_spring__food_drain_multiplier_name", 0),
			new TextKey("cfg_spring__food_drain_multiplier_help", 0),
			new TextKey("cfg_spring__stamina_drain_multiplier_name", 0),
			new TextKey("cfg_spring__stamina_drain_multiplier_help", 0),
			new TextKey("cfg_spring__fireplace_drain_multiplier_name", 0),
			new TextKey("cfg_spring__fireplace_drain_multiplier_help", 0),
			new TextKey("cfg_spring__sap_collecting_speed_multiplier_name", 0),
			new TextKey("cfg_spring__sap_collecting_speed_multiplier_help", 0),
			new TextKey("cfg_spring__rested_buff_duration_multiplier_name", 0),
			new TextKey("cfg_spring__rested_buff_duration_multiplier_help", 0),
			new TextKey("cfg_spring__wind_intensity_multiplier_name", 0),
			new TextKey("cfg_spring__wind_intensity_multiplier_help", 0),
			new TextKey("cfg_spring__rain_protection_name", 0),
			new TextKey("cfg_spring__rain_protection_help", 0),
			new TextKey("cfg_calendar__days_in_summer_name", 0),
			new TextKey("cfg_calendar__days_in_summer_help", 0),
			new TextKey("cfg_summer__plants_growth_multiplier_name", 0),
			new TextKey("cfg_summer__plants_growth_multiplier_help", 0),
			new TextKey("cfg_summer__beehive_production_multiplier_name", 0),
			new TextKey("cfg_summer__beehive_production_multiplier_help", 0),
			new TextKey("cfg_summer__food_drain_multiplier_name", 0),
			new TextKey("cfg_summer__food_drain_multiplier_help", 0),
			new TextKey("cfg_summer__stamina_drain_multiplier_name", 0),
			new TextKey("cfg_summer__stamina_drain_multiplier_help", 0),
			new TextKey("cfg_summer__fireplace_drain_multiplier_name", 0),
			new TextKey("cfg_summer__fireplace_drain_multiplier_help", 0),
			new TextKey("cfg_summer__sap_collecting_speed_multiplier_name", 0),
			new TextKey("cfg_summer__sap_collecting_speed_multiplier_help", 0),
			new TextKey("cfg_summer__rested_buff_duration_multiplier_name", 0),
			new TextKey("cfg_summer__rested_buff_duration_multiplier_help", 0),
			new TextKey("cfg_summer__wind_intensity_multiplier_name", 0),
			new TextKey("cfg_summer__wind_intensity_multiplier_help", 0),
			new TextKey("cfg_summer__rain_protection_name", 0),
			new TextKey("cfg_summer__rain_protection_help", 0),
			new TextKey("cfg_calendar__days_in_fall_name", 0),
			new TextKey("cfg_calendar__days_in_fall_help", 0),
			new TextKey("cfg_fall__plants_growth_multiplier_name", 0),
			new TextKey("cfg_fall__plants_growth_multiplier_help", 0),
			new TextKey("cfg_fall__beehive_production_multiplier_name", 0),
			new TextKey("cfg_fall__beehive_production_multiplier_help", 0),
			new TextKey("cfg_fall__food_drain_multiplier_name", 0),
			new TextKey("cfg_fall__food_drain_multiplier_help", 0),
			new TextKey("cfg_fall__stamina_drain_multiplier_name", 0),
			new TextKey("cfg_fall__stamina_drain_multiplier_help", 0),
			new TextKey("cfg_fall__fireplace_drain_multiplier_name", 0),
			new TextKey("cfg_fall__fireplace_drain_multiplier_help", 0),
			new TextKey("cfg_fall__sap_collecting_speed_multiplier_name", 0),
			new TextKey("cfg_fall__sap_collecting_speed_multiplier_help", 0),
			new TextKey("cfg_fall__rested_buff_duration_multiplier_name", 0),
			new TextKey("cfg_fall__rested_buff_duration_multiplier_help", 0),
			new TextKey("cfg_fall__wind_intensity_multiplier_name", 0),
			new TextKey("cfg_fall__wind_intensity_multiplier_help", 0),
			new TextKey("cfg_fall__rain_protection_name", 0),
			new TextKey("cfg_fall__rain_protection_help", 0),
			new TextKey("cfg_calendar__days_in_winter_name", 0),
			new TextKey("cfg_calendar__days_in_winter_help", 0),
			new TextKey("cfg_winter__plants_growth_multiplier_name", 0),
			new TextKey("cfg_winter__plants_growth_multiplier_help", 0),
			new TextKey("cfg_winter__beehive_production_multiplier_name", 0),
			new TextKey("cfg_winter__beehive_production_multiplier_help", 0),
			new TextKey("cfg_winter__food_drain_multiplier_name", 0),
			new TextKey("cfg_winter__food_drain_multiplier_help", 0),
			new TextKey("cfg_winter__stamina_drain_multiplier_name", 0),
			new TextKey("cfg_winter__stamina_drain_multiplier_help", 0),
			new TextKey("cfg_winter__fireplace_drain_multiplier_name", 0),
			new TextKey("cfg_winter__fireplace_drain_multiplier_help", 0),
			new TextKey("cfg_winter__sap_collecting_speed_multiplier_name", 0),
			new TextKey("cfg_winter__sap_collecting_speed_multiplier_help", 0),
			new TextKey("cfg_winter__rested_buff_duration_multiplier_name", 0),
			new TextKey("cfg_winter__rested_buff_duration_multiplier_help", 0),
			new TextKey("cfg_winter__wind_intensity_multiplier_name", 0),
			new TextKey("cfg_winter__wind_intensity_multiplier_help", 0),
			new TextKey("cfg_winter__rain_protection_name", 0),
			new TextKey("cfg_winter__rain_protection_help", 0)
		});

		public static string SeasonName(Season season)
		{
			return "season_" + season.ToString().ToLowerInvariant();
		}
	}
}
namespace ExtraPotions.Solstice.Integration
{
	public enum SolsticeModule
	{
		Seasons
	}
	public readonly struct InstalledPlugin
	{
		public string Guid { get; }

		public string Name { get; }

		public InstalledPlugin(string guid, string name)
		{
			Guid = guid ?? "";
			Name = name ?? "";
		}
	}
	public sealed class ModuleSource
	{
		public string Guid { get; }

		public string Name { get; }

		public SolsticeModule Module { get; }

		internal ModuleSource(string guid, string name, SolsticeModule module)
		{
			Guid = guid;
			Name = name;
			Module = module;
		}

		public bool Matches(InstalledPlugin plugin)
		{
			return string.Equals(plugin.Guid, Guid, StringComparison.Ordinal);
		}
	}
	public readonly struct StepAsideNotice
	{
		public SolsticeModule Module { get; }

		public string SourceName { get; }

		public string SourceGuid { get; }

		public string Key => KeyOf(Module);

		public StepAsideNotice(SolsticeModule module, string sourceName, string sourceGuid)
		{
			Module = module;
			SourceName = sourceName;
			SourceGuid = sourceGuid;
		}

		public static string KeyOf(SolsticeModule module)
		{
			return "step_aside_" + module.ToString().ToLowerInvariant();
		}
	}
	public sealed class ModuleStepAsideDecision
	{
		private readonly HashSet<SolsticeModule> aside;

		public IReadOnlyList<ModuleSource> Present { get; }

		public bool Any => aside.Count > 0;

		public IReadOnlyList<StepAsideNotice> Notices { get; }

		internal ModuleStepAsideDecision(IReadOnlyList<ModuleSource> present)
		{
			Present = present;
			aside = new HashSet<SolsticeModule>(present.Select((ModuleSource p) => p.Module));
			Notices = (from p in present
				orderby p.Module
				select new StepAsideNotice(p.Module, p.Name, p.Guid)).ToList();
		}

		public bool SteppedAside(SolsticeModule module)
		{
			return aside.Contains(module);
		}
	}
	public static class ModuleStepAside
	{
		public static readonly ModuleSource Seasons = new ModuleSource("shudnal.Seasons", "Seasons", SolsticeModule.Seasons);

		public static readonly ModuleSource Seasonality = new ModuleSource("RustyMods.Seasonality", "Seasonality", SolsticeModule.Seasons);

		public static IReadOnlyList<ModuleSource> Sources { get; } = Array.AsReadOnly(new ModuleSource[2] { Seasons, Seasonality });

		public static ModuleStepAsideDecision Decide(IEnumerable<InstalledPlugin> installed)
		{
			if (installed == null)
			{
				throw new ArgumentNullException("installed");
			}
			List<InstalledPlugin> list = installed.ToList();
			return new ModuleStepAsideDecision(Sources.Where((ModuleSource s) => list.Any(s.Matches)).ToList());
		}
	}
	public readonly struct SeasonClockView : IEquatable<SeasonClockView>
	{
		public const string Id = "meadworks.seasons.clock";

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

		public int Season { get; }

		public int DayInSeason { get; }

		public int DaysInSeason { get; }

		public int DayOfYear { get; }

		public int YearLength { get; }

		public int WorldDay { get; }

		public int AnchorDay { get; }

		public int Revision { get; }

		public bool Available => DaysInSeason > 0;

		public SeasonClockView(int season, int dayInSeason, int daysInSeason, int dayOfYear, int yearLength, int worldDay, int anchorDay, int revision)
		{
			Season = season;
			DayInSeason = dayInSeason;
			DaysInSeason = daysInSeason;
			DayOfYear = dayOfYear;
			YearLength = yearLength;
			WorldDay = worldDay;
			AnchorDay = anchorDay;
			Revision = revision;
		}

		public static SeasonClockView FromClock(SeasonClock clock)
		{
			return new SeasonClockView((int)clock.Season, clock.DayInSeason, clock.DaysIn(clock.Season), clock.DayOfYear, clock.YearLength, clock.WorldDay, clock.AnchorDay, clock.Revision);
		}

		public (int, int, int, int, int, int, int, int) ToTuple()
		{
			return (Season, DayInSeason, DaysInSeason, DayOfYear, YearLength, WorldDay, AnchorDay, Revision);
		}

		public static bool TryFromTuple((int, int, int, int, int, int, int, int) tuple, out SeasonClockView view)
		{
			view = default(SeasonClockView);
			int item = tuple.Item1;
			int item2 = tuple.Item2;
			int item3 = tuple.Item3;
			int item4 = tuple.Item4;
			int item5 = tuple.Item5;
			int item6 = tuple.Item6;
			int item7 = tuple.Item7;
			int item8 = tuple.Rest.Item1;
			if (item3 == 0 && item2 == 0 && item5 == 0 && item6 == 0 && item7 == 0 && item8 == 0 && item == 0 && item4 == 0)
			{
				view = default(SeasonClockView);
				return true;
			}
			if (item < 0 || item >= 4)
			{
				return false;
			}
			if (item3 < 1 || item5 < item3 || item2 < 0 || item2 > item3 || item4 < 0 || item4 > item5)
			{
				return false;
			}
			if (item6 < item7 || item6 - item7 != item2)
			{
				return false;
			}
			view = new SeasonClockView(item, item2, item3, item4, item5, item6, item7, item8);
			return true;
		}

		public bool Equals(SeasonClockView other)
		{
			if (Season == other.Season && DayInSeason == other.DayInSeason && DaysInSeason == other.DaysInSeason && DayOfYear == other.DayOfYear && YearLength == other.YearLength && WorldDay == other.WorldDay && AnchorDay == other.AnchorDay)
			{
				return Revision == other.Revision;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((((((((((((Season * 397) ^ DayInSeason) * 397) ^ DaysInSeason) * 397) ^ DayOfYear) * 397) ^ YearLength) * 397) ^ WorldDay) * 397) ^ AnchorDay) * 397) ^ Revision;
		}
	}
	public readonly struct SeasonFactValues
	{
		public bool Available { get; }

		public int Season { get; }

		public int CalendarSeason { get; }

		public int Day { get; }

		public int Length { get; }

		public int DayOfYear { get; }

		public int Year { get; }

		public int WorldDay { get; }

		public int Anchor { get; }

		public int Revision { get; }

		public bool Held { get; }

		public bool Effects { get; }

		public int NightPercent { get; }

		public float DayStart { get; }

		public float Wood { get; }

		public float Meat { get; }

		public float Breed { get; }

		public bool Torch { get; }

		public float TorchDrain { get; }

		public bool Overheat { get; }

		public float Growth { get; }

		public float Snow { get; }

		public bool Ice { get; }

		public SeasonFactValues(bool available, int season, int calendarSeason, int day, int length, int dayOfYear, int year, int worldDay, int anchor, int revision, bool held, bool effects, int nightPercent, float dayStart, float wood, float meat, float breed, bool torch, float torchDrain, bool overheat, float growth, float snow, bool ice)
		{
			Available = available;
			Season = season;
			CalendarSeason = calendarSeason;
			Day = day;
			Length = length;
			DayOfYear = dayOfYear;
			Year = year;
			WorldDay = worldDay;
			Anchor = anchor;
			Revision = revision;
			Held = held;
			Effects = effects;
			NightPercent = nightPercent;
			DayStart = dayStart;
			Wood = wood;
			Meat = meat;
			Breed = breed;
			Torch = torch;
			TorchDrain = torchDrain;
			Overheat = overheat;
			Growth = growth;
			Snow = snow;
			Ice = ice;
		}
	}
	public static class SeasonFacts
	{
		public const string Id = "meadworks.seasons.facts";

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

		public static string Format(SeasonFactValues facts)
		{
			if (!facts.Available)
			{
				return "";
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			return string.Join(";", "season=" + facts.Season.ToString(invariantCulture), "calendar=" + facts.CalendarSeason.ToString(invariantCulture), "day=" + facts.Day.ToString(invariantCulture), "length=" + facts.Length.ToString(invariantCulture), "doy=" + facts.DayOfYear.ToString(invariantCulture), "year=" + facts.Year.ToString(invariantCulture), "world=" + facts.WorldDay.ToString(invariantCulture), "anchor=" + facts.Anchor.ToString(invariantCulture), "rev=" + facts.Revision.ToString(invariantCulture), "held=" + (facts.Held ? "1" : "0"), "effects=" + (facts.Effects ? "1" : "0"), "night=" + facts.NightPercent.ToString(invariantCulture), "daystart=" + facts.DayStart.ToString("0.###", invariantCulture), "wood=" + facts.Wood.ToString("0.###", invariantCulture), "meat=" + facts.Meat.ToString("0.###", invariantCulture), "breed=" + facts.Breed.ToString("0.###", invariantCulture), "torch=" + (facts.Torch ? "1" : "0"), "torchdrain=" + facts.TorchDrain.ToString("0.###", invariantCulture), "overheat=" + (facts.Overheat ? "1" : "0"), "growth=" + facts.Growth.ToString("0.###", invariantCulture), "snow=" + facts.Snow.ToString("0.###", invariantCulture), "ice=" + (facts.Ice ? "1" : "0"));
		}

		public static bool TryGet(string? text, string key, out string value)
		{
			value = "";
			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(key))
			{
				return false;
			}
			string[] array = text.Split(';');
			foreach (string text2 in array)
			{
				int num = text2.IndexOf('=');
				if (num > 0 && string.Equals(text2.Substring(0, num), key, StringComparison.Ordinal))
				{
					value = text2.Substring(num + 1);
					return true;
				}
			}
			return false;
		}
	}
	public readonly struct SeasonView : IEquatable<SeasonView>
	{
		public const string Id = "meadworks.seasons.view";

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

		public int Season { get; }

		public int DayInSeason { get; }

		public int DaysInSeason { get; }

		public int DayOfYear { get; }

		public int YearLength { get; }

		public int Revision { get; }

		public bool Available => DaysInSeason > 0;

		public SeasonView(int season, int dayInSeason, int daysInSeason, int dayOfYear, int yearLength, int revision)
		{
			Season = season;
			DayInSeason = dayInSeason;
			DaysInSeason = daysInSeason;
			DayOfYear = dayOfYear;
			YearLength = yearLength;
			Revision = revision;
		}

		public static SeasonView Read(SeasonCalendar calendar, int day, Season? forced = null)
		{
			if (calendar == null)
			{
				throw new ArgumentNullException("calendar");
			}
			SeasonPosition seasonPosition = calendar.At(day);
			Season season = forced ?? seasonPosition.Season;
			int num = calendar.DaysIn(season);
			return new SeasonView((int)season, Math.Min(seasonPosition.DayInSeason, num), num, seasonPosition.DayOfYear, calendar.YearLength, 0);
		}

		public static SeasonView FromClock(SeasonClock clock, Season? forced = null)
		{
			Season season = forced ?? clock.Season;
			int num = clock.DaysIn(season);
			int dayInSeason = Math.Min(Math.Max(0, clock.DayInSeason), num);
			return new SeasonView((int)season, dayInSeason, num, clock.DayOfYear, clock.YearLength, 0);
		}

		public SeasonView WithRevision(int revision)
		{
			return new SeasonView(Season, DayInSeason, DaysInSeason, DayOfYear, YearLength, revision);
		}

		public Tuple<int, int, int, int, int, int> ToTuple()
		{
			return Tuple.Create(Season, DayInSeason, DaysInSeason, DayOfYear, YearLength, Revision);
		}

		public static SeasonView FromTuple(Tuple<int, int, int, int, int, int> tuple)
		{
			if (!TryFromTuple(tuple, out var view))
			{
				throw new ArgumentException("Invalid season reading.", "tuple");
			}
			return view;
		}

		public static bool TryFromTuple(Tuple<int, int, int, int, int, int>? tuple, out SeasonView view)
		{
			view = default(SeasonView);
			if (tuple == null)
			{
				return false;
			}
			int item = tuple.Item1;
			int item2 = tuple.Item2;
			int item3 = tuple.Item3;
			int item4 = tuple.Item4;
			int item5 = tuple.Item5;
			if (item < 0 || item >= 4)
			{
				return false;
			}
			if (item3 < 0 || item5 < item3 || item2 < 0 || item2 > item3 || item4 < 0 || item4 > item5)
			{
				return false;
			}
			view = new SeasonView(item, item2, item3, item4, item5, tuple.Item6);
			return true;
		}

		public bool Equals(SeasonView other)
		{
			if (Season == other.Season && DayInSeason == other.DayInSeason && DaysInSeason == other.DaysInSeason && DayOfYear == other.DayOfYear && YearLength == other.YearLength)
			{
				return Revision == other.Revision;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((((((((Season * 397) ^ DayInSeason) * 397) ^ DaysInSeason) * 397) ^ DayOfYear) * 397) ^ YearLength) * 397) ^ Revision;
		}
	}
	public sealed class SeasonViewRevision
	{
		private int revision;

		private bool seen;

		private SeasonView last;

		public int Observe(SeasonView view)
		{
			SeasonView seasonView = view.WithRevision(0);
			if (!seen || !seasonView.Equals(last))
			{
				seen = true;
				last = seasonView;
				revision++;
			}
			return revision;
		}

		public SeasonView Stamp(SeasonView view)
		{
			return view.WithRevision(Observe(view));
		}
	}
	public enum YieldReason
	{
		None,
		TempestEvent,
		ForcedEnvironment
	}
	public readonly struct WeatherYieldDecision
	{
		public bool Yield { get; }

		public YieldReason Reason { get; }

		public WeatherYieldDecision(bool yield, YieldReason reason)
		{
			Yield = yield;
			Reason = reason;
		}
	}
	public static class WeatherYield
	{
		public const float MaxDeferSeconds = 3600f;

		public static WeatherYieldDecision Decide(bool tempestRunning, bool tempestLocalAffected, bool gameForced)
		{
			if (gameForced)
			{
				return new WeatherYieldDecision(yield: true, YieldReason.ForcedEnvironment);
			}
			if (tempestRunning && tempestLocalAffected)
			{
				return new WeatherYieldDecision(yield: true, YieldReason.TempestEvent);
			}
			return new WeatherYieldDecision(yield: false, YieldReason.None);
		}
	}
	public sealed class EnvironmentRefresh
	{
		private double since;

		public bool Pending { get; private set; }

		public void Request(double now)
		{
			if (!Pending)
			{
				Pending = true;
				since = now;
			}
		}

		public bool Tick(double now, WeatherYieldDecision decision)
		{
			if (!Pending)
			{
				return false;
			}
			if (decision.Yield && now - since < 3600.0)
			{
				return false;
			}
			Pending = false;
			return true;
		}

		public void Cancel()
		{
			Pending = false;
		}
	}
}
namespace ExtraPotions.Solstice.Effects
{
	public static class ClimateRules
	{
		public const float OverheatRegen = 0.8f;

		public const int WaterFreezesFromDay = 6;

		public const int WaterFreezesUntilDay = 9;

		public static bool StatusApplies(bool enabled, bool interior, bool ashlandsOrDeepNorth)
		{
			if (enabled && !interior)
			{
				return !ashlandsOrDeepNorth;
			}
			return false;
		}

		public static bool Overheating(bool settingOn, bool seasonOverheats, bool shelteredOrCold, int warmClothes, bool coolingFood)
		{
			if (settingOn && seasonOverheats && !shelteredOrCold && !coolingFood)
			{
				return warmClothes > 1;
			}
			return false;
		}

		public static float SnowCover(Season season, int dayInSeason, int daysInSeason, bool placeProtected, bool heatProtected)
		{
			if (season != Season.Winter || placeProtected || heatProtected || daysInSeason < 1 || dayInSeason < 1)
			{
				return 0f;
			}
			float num = (float)dayInSeason / (float)daysInSeason;
			if (!(num > 1f))
			{
				return num;
			}
			return 1f;
		}

		public static bool WaterFrozen(Season season, int dayInSeason)
		{
			if (season == Season.Winter && dayInSeason >= 6)
			{
				return dayInSeason <= 9;
			}
			return false;
		}
	}
	public sealed class CropFreezeTimer
	{
		private bool observing;

		private long previousBudget;

		private double previousTime;

		public long Advance(long budget, bool owner, double now)
		{
			if (!owner)
			{
				observing = false;
				return budget;
			}
			if (!observing || budget != previousBudget)
			{
				observing = true;
				previousBudget = budget;
				previousTime = now;
				return budget;
			}
			double num = Math.Max(0.0, now - previousTime);
			long num2 = ((double.IsNaN(num) || double.IsInfinity(num)) ? 0 : ((long)(num * 1000.0)));
			long result = (previousBudget = ((budget > 0) ? Math.Max(1L, budget - num2) : 0));
			previousTime = now;
			return result;
		}
	}
	public enum CropWinterAction
	{
		None,
		ClearFreeze,
		BeginFreeze,
		StayFreezing,
		Survive,
		Perish
	}
	public enum CropHover
	{
		None,
		FrostResistant,
		HeatProtected,
		Survived,
		Freezing,
		WillPerish,
		Exposed
	}
	public readonly struct CropWinterDecision
	{
		public CropWinterAction Action { get; }

		public CropHover Hover { get; }

		public int HoverSeconds { get; }

		public CropWinterDecision(CropWinterAction action, CropHover hover, int hoverSeconds)
		{
			Action = action;
			Hover = hover;
			HoverSeconds = hoverSeconds;
		}
	}
	public static class CropWinter
	{
		public const int DefaultPerishDay = 3;

		public const float DefaultFreezeSeconds = 120f;

		public const float DefaultHarvestChance = 0.33f;

		public static float FreezeWindow(float seconds)
		{
			if (!(seconds < 0f))
			{
				return seconds;
			}
			return 0f;
		}

		public static string PrefabName(string? name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "";
			}
			int num = name.IndexOf("(Clone)", StringComparison.Ordinal);
			if (num < 0)
			{
				return name;
			}
			if (num > 0 && name[num - 1] == ' ')
			{
				num--;
			}
			return name.Substring(0, num);
		}

		public static bool SurvivedWinter(int savedDay, int anchorDay, int length)
		{
			if (savedDay > anchorDay)
			{
				return savedDay <= (long)anchorDay + (long)length;
			}
			return false;
		}

		public static CropWinterDecision Decide(bool perishEnabled, bool winterStopped, bool canBePicked, bool alreadyPicked, bool controlled, bool placeProtected, bool hardy, bool heatProtected, bool alreadySurvived, int dayInSeason, int perishFromDay, float freezeSeconds, float harvestChance, bool freezeStarted, double secondsRemaining, double roll)
		{
			if (!(perishEnabled && winterStopped && controlled && canBePicked) || alreadyPicked)
			{
				if (!freezeStarted)
				{
					return None(CropHover.None);
				}
				return Clear(CropHover.None);
			}
			if (placeProtected)
			{
				if (!freezeStarted)
				{
					return None(CropHover.None);
				}
				return Clear(CropHover.None);
			}
			if (hardy)
			{
				if (!freezeStarted)
				{
					return None(CropHover.FrostResistant);
				}
				return Clear(CropHover.FrostResistant);
			}
			if (heatProtected)
			{
				if (!freezeStarted)
				{
					return None(CropHover.HeatProtected);
				}
				return Clear(CropHover.HeatProtected);
			}
			if (alreadySurvived)
			{
				if (!freezeStarted)
				{
					return None(CropHover.Survived);
				}
				return Clear(CropHover.Survived);
			}
			if (dayInSeason < perishFromDay)
			{
				if (!freezeStarted)
				{
					return None(CropHover.Exposed);
				}
				return Clear(CropHover.Exposed);
			}
			float num = FreezeWindow(freezeSeconds);
			if (num > 0f)
			{
				if (!freezeStarted)
				{
					return new CropWinterDecision(CropWinterAction.BeginFreeze, CropHover.Freezing, WholeSeconds(num));
				}
				if (secondsRemaining > 0.0)
				{
					return new CropWinterDecision(CropWinterAction.StayFreezing, CropHover.Freezing, WholeSeconds(secondsRemaining));
				}
			}
			if (KeepsCrop(roll, harvestChance))
			{
				return new CropWinterDecision(CropWinterAction.Survive, CropHover.Survived, 0);
			}
			return new CropWinterDecision(CropWinterAction.Perish, CropHover.WillPerish, 0);
		}

		public static double Roll(long id, int worldDay)
		{
			long num = (id * -7046029254386353131L) ^ (uint)worldDay;
			long num2 = (num ^ (num >>> 30)) * -4658895280553007687L;
			long num3 = (num2 ^ (num2 >>> 27)) * -7723592293110705685L;
			return (double)(ulong)((num3 ^ (num3 >>> 31)) & 0xFFFFFF) / 16777216.0;
		}

		private static bool KeepsCrop(double roll, float harvestChance)
		{
			if (double.IsNaN(roll) || roll < 0.0 || roll >= 1.0)
			{
				return true;
			}
			if (harvestChance <= 0f)
			{
				return false;
			}
			if (harvestChance >= 1f)
			{
				return true;
			}
			return roll < (double)harvestChance;
		}

		private static int WholeSeconds(double seconds)
		{
			return (int)Math.Ceiling((seconds < 1.0) ? 1.0 : seconds);
		}

		private static CropWinterDecision None(CropHover hover)
		{
			return new CropWinterDecision(CropWinterAction.None, hover, 0);
		}

		private static CropWinterDecision Clear(CropHover hover)
		{
			return new CropWinterDecision(CropWinterAction.ClearFreeze, hover, 0);
		}
	}
	public enum PositionProtection
	{
		None,
		Interior,
		Terrain,
		Shield
	}
	public readonly struct PositionFacts
	{
		public bool Interior { get; }

		public bool AshlandsOrDeepNorth { get; }

		public bool HighMountain { get; }

		public bool InsideShield { get; }

		public PositionFacts(bool interior, bool ashlandsOrDeepNorth, bool highMountain, bool insideShield)
		{
			Interior = interior;
			AshlandsOrDeepNorth = ashlandsOrDeepNorth;
			HighMountain = highMountain;
			InsideShield = insideShield;
		}
	}
	public sealed class ProtectionRules
	{
		private readonly bool shield;

		private readonly bool winterOnly;

		public ProtectionRules(bool shieldProtects, bool shieldWinterOnly)
		{
			shield = shieldProtects;
			winterOnly = shieldWinterOnly;
		}

		public bool ShieldActive(Season season)
		{
			if (shield)
			{
				if (winterOnly)
				{
					return season == Season.Winter;
				}
				return true;
			}
			return false;
		}

		public PositionProtection Decide(PositionFacts facts, Season season)
		{
			if (facts.Interior)
			{
				return PositionProtection.Interior;
			}
			if (facts.AshlandsOrDeepNorth || facts.HighMountain)
			{
				return PositionProtection.Terrain;
			}
			if (ShieldActive(season) && facts.InsideShield)
			{
				return PositionProtection.Shield;
			}
			return PositionProtection.None;
		}
	}
	public sealed class WinterCrops
	{
		private readonly HashSet<string> names;

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

		public static WinterCrops Parse(string? list)
		{
			return new WinterCrops(new HashSet<string>(from n in (list ?? "").Split(',')
				select n.Trim().ToLowerInvariant() into n
				where n.Length > 0
				select n, StringComparer.Ordinal));
		}

		public static string Normalize(string? list)
		{
			return string.Join(",", from n in (list ?? "").Split(',')
				select n.Trim() into n
				where n.Length > 0
				select n);
		}

		public bool Survives(bool toleratesCold, IEnumerable<string> grownPrefabNames)
		{
			if (!toleratesCold)
			{
				return grownPrefabNames.Any((string n) => names.Contains((n ?? "").ToLowerInvariant()));
			}
			return true;
		}
	}
	public static class ColdPlants
	{
		public static bool IsTooCold(bool healthy, Season season, float growthMultiplier, bool hardy, bool heatProtected)
		{
			if (healthy && season == Season.Winter && growthMultiplier == 0f && !hardy)
			{
				return !heatProtected;
			}
			return false;
		}

		public static double AdjustedAge(double secondsSincePlanted, Season season, float growthMultiplier)
		{
			if (secondsSincePlanted != 0.0 || growthMultiplier != 0f || season != Season.Winter)
			{
				return secondsSincePlanted;
			}
			return 11.0;
		}
	}
	public sealed class SeasonEffects
	{
		public static readonly IReadOnlyList<string> Wired = Array.AsReadOnly(new string[9] { "PlantsGrowthMultiplier", "BeehiveProductionMultiplier", "FoodDrainMultiplier", "StaminaDrainMultiplier", "FireplaceDrainMultiplier", "SapCollectingSpeedMultiplier", "RestedBuffDurationMultiplier", "WindIntensityMultiplier", "RainProtection" });

		public int DaysInSeason { get; set; } = 10;

		public int NightLength { get; set; } = 30;

		public bool TorchAsFiresource { get; set; }

		public float TorchDurabilityDrain { get; set; } = 0.1f;

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

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

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

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

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

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

		public bool RainProtection { get; set; }

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

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

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

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

		public bool OverheatIn2WarmClothes { get; set; }

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

		public float TreesRegrowthChance { get; set; }

		public SeasonEffects Clone()
		{
			return (SeasonEffects)MemberwiseClone();
		}

		public static SeasonEffects Defaults(Season season)
		{
			SeasonEffects seasonEffects = new SeasonEffects();
			switch (season)
			{
			case Season.Spring:
				seasonEffects.PlantsGrowthMultiplier = 2f;
				seasonEffects.BeehiveProductionMultiplier = 0.5f;
				seasonEffects.FireplaceDrainMultiplier = 0.75f;
				seasonEffects.SapCollectingSpeedMultiplier = 2f;
				seasonEffects.WoodFromTreesMultiplier = 0.75f;
				seasonEffects.WindIntensityMultiplier = 0.9f;
				seasonEffects.RestedBuffDurationMultiplier = 1.25f;
				seasonEffects.LivestockProcreationMultiplier = 1.5f;
				seasonEffects.MeatFromAnimalsMultiplier = 0.5f;
				seasonEffects.TreesRegrowthChance = 0.9f;
				break;
			case Season.Summer:
				seasonEffects.PlantsGrowthMultiplier = 1.5f;
				seasonEffects.BeehiveProductionMultiplier = 2f;
				seasonEffects.FoodDrainMultiplier = 0.75f;
				seasonEffects.NightLength = 15;
				seasonEffects.StaminaDrainMultiplier = 0.8f;
				seasonEffects.FireplaceDrainMultiplier = 0.25f;
				seasonEffects.SapCollectingSpeedMultiplier = 1.25f;
				seasonEffects.WoodFromTreesMultiplier = 0.75f;
				seasonEffects.WindIntensityMultiplier = 1.1f;
				seasonEffects.RestedBuffDurationMultiplier = 1.5f;
				seasonEffects.LivestockProcreationMultiplier = 1.25f;
				seasonEffects.OverheatIn2WarmClothes = true;
				seasonEffects.MeatFromAnimalsMultiplier = 0.75f;
				seasonEffects.TreesRegrowthChance = 0.75f;
				break;
			case Season.Fall:
				seasonEffects.PlantsGrowthMultiplier = 0.5f;
				seasonEffects.BeehiveProductionMultiplier = 1.5f;
				seasonEffects.FireplaceDrainMultiplier = 1f;
				seasonEffects.TorchAsFiresource = true;
				seasonEffects.SapCollectingSpeedMultiplier = 0.5f;
				seasonEffects.WoodFromTreesMultiplier = 1.25f;
				seasonEffects.WindIntensityMultiplier = 1.2f;
				seasonEffects.RestedBuffDurationMultiplier = 0.85f;
				seasonEffects.LivestockProcreationMultiplier = 0.75f;
				seasonEffects.MeatFromAnimalsMultiplier = 1.25f;
				seasonEffects.TreesRegrowthChance = 0.25f;
				break;
			case Season.Winter:
				seasonEffects.PlantsGrowthMultiplier = 0f;
				seasonEffects.BeehiveProductionMultiplier = 0f;
				seasonEffects.FoodDrainMultiplier = 1.25f;
				seasonEffects.NightLength = 45;
				seasonEffects.TorchAsFiresource = true;
				seasonEffects.StaminaDrainMultiplier = 1.2f;
				seasonEffects.FireplaceDrainMultiplier = 2f;
				seasonEffects.SapCollectingSpeedMultiplier = 0.25f;
				seasonEffects.RainProtection = true;
				seasonEffects.WoodFromTreesMultiplier = 1.5f;
				seasonEffects.WindIntensityMultiplier = 0.9f;
				seasonEffects.RestedBuffDurationMultiplier = 0.75f;
				seasonEffects.LivestockProcreationMultiplier = 0.5f;
				seasonEffects.MeatFromAnimalsMultiplier = 1.5f;
				seasonEffects.TreesRegrowthChance = 0f;
				break;
			default:
				throw new ArgumentOutOfRangeException("season");
			}
			return seasonEffects;
		}

		public static SeasonCalendar CalendarOf(Func<Season, int> daysIn)
		{
			return new SeasonCalendar(daysIn(Season.Spring), daysIn(Season.Summer), daysIn(Season.Fall), daysIn(Season.Winter));
		}
	}
	public sealed class SeasonStatModifiers
	{
		public float TickInterval { get; set; }

		public float HealthPerTickMinHealthPercentage { get; set; }

		public float HealthPerTick { get; set; }

		public string HealthHitType { get; set; } = "";

		public float RunStaminaDrainModifier { get; set; }

		public float JumpStaminaUseModifier { get; set; }

		public float AttackStaminaUseModifier { get; set; }

		public float BlockStaminaUseModifier { get; set; }

		public float BlockStaminaUseFlatValue { get; set; }

		public float DodgeStaminaUseModifier { get; set; }

		public float SwimStaminaUseModifier { get; set; }

		public float HomeItemStaminaUseModifier { get; set; }

		public float SneakStaminaUseModifier { get; set; }

		public float RunStaminaUseModifier { get; set; }

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

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

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

		public Dictionary<string, float> RaiseSkills { get; } = new Dictionary<string, float>();

		public Dictionary<string, float> SkillLevels { get; } = new Dictionary<string, float>();

		public Dictionary<string, float> ModifyAttackSkills { get; } = new Dictionary<string, float>();

		public Dictionary<string, string> DamageModifiers { get; } = new Dictionary<string, string>();

		public float NoiseModifier { get; set; }

		public float StealthModifier { get; set; }

		public float AddMaxCarryWeight { get; set; }

		public float SpeedModifier { get; set; }

		public float SwimSpeedModifier { get; set; }

		public float MaxMaxFallSpeed { get; set; }

		public float FallDamageModifier { get; set; }

		public float AdrenalineModifier { get; set; }

		public float StaggerModifier { get; set; }

		public float TimedBlockBonus { get; set; }
	}
	public static class SeasonStatTable
	{
		public static SeasonStatModifiers Defaults(Season season)
		{
			SeasonStatModifiers seasonStatModifiers = new SeasonStatModifiers();
			switch (season)
			{
			case Season.Spring:
			{
				seasonStatModifiers.TickInterval = 5f;
				seasonStatModifiers.HealthPerTick = 1f;
				seasonStatModifiers.DamageModifiers["Poison"] = "Resistant";
				string[] array = new string[4] { "Jump", "Sneak", "Run", "Swim" };
				foreach (string key4 in array)
				{
					seasonStatModifiers.RaiseSkills[key4] = 1.2f;
					seasonStatModifiers.SkillLevels[key4] = 15f;
				}
				break;
			}
			case Season.Summer:
			{
				seasonStatModifiers.RunStaminaDrainModifier = -0.1f;
				seasonStatModifiers.JumpStaminaUseModifier = -0.1f;
				seasonStatModifiers.HealthRegenMultiplier = 1.1f;
				seasonStatModifiers.NoiseModifier = -0.2f;
				seasonStatModifiers.StealthModifier = 0.2f;
				seasonStatModifiers.SpeedModifier = 0.05f;
				string[] array = new string[4] { "Jump", "Sneak", "Run", "Swim" };
				foreach (string key2 in array)
				{
					seasonStatModifiers.RaiseSkills[key2] = 1.1f;
					seasonStatModifiers.SkillLevels[key2] = 10f;
				}
				break;
			}
			case Season.Fall:
			{
				seasonStatModifiers.EitrRegenMultiplier = 1.1f;
				string[] array = new string[3] { "WoodCutting", "Fishing", "Pickaxes" };
				foreach (string key3 in array)
				{
					seasonStatModifiers.RaiseSkills[key3] = 1.2f;
					seasonStatModifiers.SkillLevels[key3] = 15f;
				}
				break;
			}
			case Season.Winter:
			{
				seasonStatModifiers.StaminaRegenMultiplier = 1.1f;
				seasonStatModifiers.NoiseModifier = 0.2f;
				seasonStatModifiers.StealthModifier = -0.2f;
				seasonStatModifiers.SpeedModifier = -0.05f;
				seasonStatModifiers.FallDamageModifier = -0.3f;
				seasonStatModifiers.DamageModifiers["Fire"] = "Resistant";
				string[] array = new string[3] { "WoodCutting", "Fishing", "Pickaxes" };
				foreach (string key in array)
				{
					seasonStatModifiers.RaiseSkills[key] = 1.1f;
					seasonStatModifiers.SkillLevels[key] = 10f;
				}
				break;
			}
			default:
				throw new ArgumentOutOfRangeException("season");
			}
			return seasonStatModifiers;
		}
	}
}
namespace ExtraPotions.Solstice.Config
{
	public readonly struct ImportChange
	{
		public string Id { get; }

		public string Text { get; }

		public ImportChange(string id, string text)
		{
			Id = id;
			Text = text;
		}
	}
	public sealed class ImportPlan
	{
		public bool Ok { get; set; }

		public string Error { get; set; } = "";

		public List<ImportChange> Changes { get; } = new List<ImportChange>();

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

		public List<string> Unknown { get; } = new List<string>();
	}
	public static class SeasonConfigImport
	{
		private static readonly Dictionary<string, string> Fields = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["daysInSeason"] = "Calendar",
			["plantsGrowthMultiplier"] = "Plants Growth Multiplier",
			["beehiveProductionMultiplier"] = "Beehive Production Multiplier",
			["foodDrainMultiplier"] = "Food Drain Multiplier",
			["staminaDrainMultiplier"] = "Stamina Drain Multiplier",
			["fireplaceDrainMultiplier"] = "Fireplace Drain Multiplier",
			["sapCollectingSpeedMultiplier"] = "Sap Collecting Speed Multiplier",
			["rainProtection"] = "Rain Protection",
			["windIntensityMultiplier"] = "Wind Intensity Multiplier",
			["restedBuffDurationMultiplier"] = "Rested Buff Duration Multiplier"
		};

		private static readonly HashSet<string> OwnedElsewhere = new HashSet<string>(StringComparer.Ordinal) { "nightLength", "torchAsFiresource", "torchDurabilityDrain", "woodFromTreesMultiplier", "livestockProcreationMultiplier", "meatFromAnimalsMultiplier", "treesRegrowthChance", "overheatIn2WarmClothes" };

		public static bool ShouldApply(string? current, string? factoryDefault, string? proposed)
		{
			if (current != null && factoryDefault != null && proposed != null && string.Equals(current, factoryDefault, StringComparison.Ordinal))
			{
				return !string.Equals(proposed, factoryDefault, StringComparison.Ordinal);
			}
			return false;
		}

		public static ImportPlan Plan(string? json)
		{
			ImportPlan importPlan = new ImportPlan();
			if (string.IsNullOrWhiteSpace(json))
			{
				importPlan.Error = "Import file is empty.";
				return importPlan;
			}
			JsonValue jsonValue;
			try
			{
				jsonValue = JsonReader.Parse(json);
			}
			catch (FormatException ex)
			{
				importPlan.Error = ex.Message;
				return importPlan;
			}
			if (jsonValue.Kind != JsonKind.Object)
			{
				importPlan.Error = "Import file must be a JSON object.";
				return importPlan;
			}
			importPlan.Ok = true;
			if (jsonValue.Object.ContainsKey("spring") || jsonValue.Object.ContainsKey("summer") || jsonValue.Object.ContainsKey("fall") || jsonValue.Object.ContainsKey("winter"))
			{
				Season[] all = Seasons.All;
				for (int i = 0; i < all.Length; i++)
				{
					Season season = all[i];
					ReadSeason(importPlan, season, Child(jsonValue, season.ToString().ToLowerInvariant()));
				}
				return importPlan;
			}
			if (!TrySeason(Child(jsonValue, "season"), out var season2))
			{
				importPlan.Ok = false;
				importPlan.Error = "Import file needs spring, summer, fall and winter objects, or a season field.";
				return importPlan;
			}
			ReadSeason(importPlan, season2, jsonValue);
			return importPlan;
		}

		private static void ReadSeason(ImportPlan plan, Season season, JsonValue? body)
		{
			if (body == null)
			{
				return;
			}
			if (body.Kind != JsonKind.Object)
			{
				plan.Unknown.Add(season.ToString().ToLowerInvariant());
				return;
			}
			foreach (KeyValuePair<string, JsonValue> item in body.Object)
			{
				if (!(item.Key == "season"))
				{
					if (OwnedElsewhere.Contains(item.Key))
					{
						plan.Unmapped.Add(season.ToString().ToLowerInvariant() + "." + item.Key);
						continue;
					}
					if (!Fields.TryGetValue(item.Key, out string value))
					{
						plan.Unknown.Add(season.ToString().ToLowerInvariant() + "." + item.Key);
						continue;
					}
					if (!TryText(item.Value, out string text))
					{
						plan.Unknown.Add(season.ToString().ToLowerInvariant() + "." + item.Key);
						continue;
					}
					string id = ((value == "Calendar") ? ("Calendar.Days In " + season) : (season.ToString() + "." + value));
					plan.Changes.Add(new ImportChange(id, text));
				}
			}
		}

		private static bool TryText(JsonValue value, out string text)
		{
			text = "";
			switch (value.Kind)
			{
			case JsonKind.Bool:
				text = (value.Bool ? "true" : "false");
				return true;
			case JsonKind.Number:
				text = value.Number.ToString("0.###", CultureInfo.InvariantCulture);
				return true;
			case JsonKind.String:
				text = value.Text ?? "";
				return true;
			default:
				return false;
			}
		}

		private static JsonValue? Child(JsonValue root, string name)
		{
			if (root.Object == null || !root.Object.TryGetValue(name, out JsonValue value))
			{
				return null;
			}
			return value;
		}

		private static bool TrySeason(JsonValue? value, out Season season)
		{
			season = Season.Spring;
			if (value == null || value.Kind != JsonKind.String || value.Text == null)
			{
				return false;
			}
			if (Enum.TryParse<Season>(value.Text, ignoreCase: true, out season))
			{
				return Enum.IsDefined(typeof(Season), season);
			}
			return false;
		}
	}
	internal enum JsonKind
	{
		Null,
		Bool,
		Number,
		String,
		Object,
		Array
	}
	internal sealed class JsonValue
	{
		public JsonKind Kind;

		public bool Bool;

		public double Number;

		public string? Text;

		public Dictionary<string, JsonValue>? Object;
	}
	internal sealed class JsonReader
	{
		private readonly string text;

		private int index;

		private JsonReader(string text)
		{
			this.text = text;
		}

		public static JsonValue Parse(string text)
		{
			JsonReader jsonReader = new JsonReader(text);
			JsonValue result = jsonReader.ReadValue();
			jsonReader.Skip();
			if (jsonReader.index != jsonReader.text.Length)
			{
				throw new FormatException("Import file has trailing text.");
			}
			return result;
		}

		private JsonValue ReadValue()
		{
			Skip();
			if (index >= text.Length)
			{
				throw new FormatException("Import file ended early.");
			}
			switch (text[index])
			{
			case '{':
				return ReadObject();
			case '[':
				return ReadArray();
			case '"':
				return new JsonValue
				{
					Kind = JsonKind.String,
					Text = ReadString()
				};
			case 'f':
			case 't':
				return ReadBool();
			case 'n':
				return ReadNull();
			case '-':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				return ReadNumber();
			default:
				throw new FormatException("Import file has a value Solstice does not read.");
			}
		}

		private JsonValue ReadObject()
		{
			index++;
			Dictionary<string, JsonValue> dictionary = new Dictionary<string, JsonValue>(StringComparer.Ordinal);
			Skip();
			if (index < text.Length && text[index] == '}')
			{
				index++;
				return new JsonValue
				{
					Kind = JsonKind.Object,
					Object = dictionary
				};
			}
			while (true)
			{
				Skip();
				if (index >= text.Length || text[index] != '"')
				{
					throw new FormatException("Import file has an object key that is not text.");
				}
				string key = ReadString();
				Skip();
				if (index >= text.Length || text[index] != ':')
				{
					throw new FormatException("Import file is missing a colon.");
				}
				index++;
				dictionary[key] = ReadValue();
				Skip();
				if (index >= text.Length)
				{
					throw new FormatException("Import file ended inside an object.");
				}
				if (text[index] != ',')
				{
					break;
				}
				index++;
			}
			if (text[index] == '}')
			{
				index++;
				return new JsonValue
				{
					Kind = JsonKind.Object,
					Object = dictionary
				};
			}
			throw new FormatException("Import file has a broken object.");
		}

		private JsonValue ReadArray()
		{
			index++;
			Skip();
			if (index < text.Length && text[index] == ']')
			{
				index++;
				return new JsonValue
				{
					Kind = JsonKind.Array
				};
			}
			while (true)
			{
				ReadValue();
				Skip();
				if (index >= text.Length)
				{
					throw new FormatException("Import file ended inside a list.");
				}
				if (text[index] != ',')
				{
					break;
				}
				index++;
			}
			if (text[index] == ']')
			{
				index++;
				return new JsonValue
				{
					Kind = JsonKind.Array
				};
			}
			throw new FormatException("Import file has a broken list.");
		}

		private JsonValue ReadBool()
		{
			if (Match("true"))
			{
				return new JsonValue
				{
					Kind = JsonKind.Bool,
					Bool = true
				};
			}
			if (Match("false"))
			{
				return new JsonValue
				{
					Kind = JsonKind.Bool,
					Bool = false
				};
			}
			throw new FormatException("Import file has a broken boolean.");
		}

		private JsonValue ReadNull()
		{
			if (!Match("null"))
			{
				throw new FormatException("Import file has a broken null.");
			}
			return new JsonValue
			{
				Kind = JsonKind.Null
			};
		}

		private JsonValue ReadNumber()
		{
			int num = index;
			if (text[index] == '-')
			{
				index++;
			}
			while (index < text.Length && text[index] >= '0' && text[index] <= '9')
			{
				index++;
			}
			if (index < text.Length && text[index] == '.')
			{
				index++;
				while (index < text.Length && text[index] >= '0' && text[index] <= '9')
				{
					index++;
				}
			}
			if (index < text.Length && (text[index] == 'e' || text[index] == 'E'))
			{