using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using ExtraPotions.Tempest.Config;
using ExtraPotions.Tempest.Events;
using ExtraPotions.Tempest.Localization;
using ExtraPotions.Tempest.Weather;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtraPotions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2026 expDARE (ExtraPotions Meadworks)")]
[assembly: AssemblyFileVersion("0.1.15.0")]
[assembly: AssemblyInformationalVersion("0.1.15+570907621cf8cf31bf960deb7d50bfbe8f5ca425")]
[assembly: AssemblyProduct("Tempest.Core")]
[assembly: AssemblyTitle("Tempest.Core")]
[assembly: AssemblyVersion("0.1.15.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ExtraPotions.Tempest
{
	public static class TempestCore
	{
		public const string PluginGuid = "com.meadworks.tempest";

		public const string ProductName = "Tempest";

		public const string ProductVersion = "0.1.15";

		public const string Family = "Runestone";

		public const string TokenNamespace = "tempest";

		public const string TokenPrefix = "meadworks_tempest_";

		public const string WorldKey = "mw.tempest.event";

		public const string DryWorldKey = "mw.tempest.lightningstorm";

		public const string ExtendedWorldKey = "mw.tempest.extended";

		public const string LegacyWorldKey = "tempest.event";

		public const string SupportedGameVersion = "1.0.17";
	}
}
namespace ExtraPotions.Tempest.Weather
{
	public enum FreezeLevel
	{
		Freezing,
		Cold,
		None
	}
	public static class EnvironmentPlan
	{
		public enum CloneStyle
		{
			Copy,
			Dry,
			DenseFog,
			VisualOnly,
			Whiteout
		}

		public const string BlizzardEnvironment = "Tempest_Blizzard";

		public const string StormEnvironment = "Tempest_Storm";

		public const string DryStormEnvironment = "Tempest_LightningStorm";

		public const string FogEnvironment = "Tempest_Fog";

		public const string AshStormEnvironment = "Tempest_AshStorm";

		public const string MeteorShowerEnvironment = "Tempest_MeteorShower";

		public const string WhiteoutEnvironment = "Tempest_Whiteout";

		public const string Haze = "Misty";

		public const string LightSnow = "Snow";

		public const string LightRain = "LightRain";

		public const string AshHaze = "Ashlands_misty";

		public const string AshRain = "Ashlands_ashrain";

		public const string NorthSnow = "Twilight_Snow";

		public const int BuildUpSeconds = 60;

		public const float DenseFogDensity = 0.16f;

		public const float WhiteoutFogDensity = 0.1f;

		public const float WhiteoutWind = 0.9f;

		public static IReadOnlyList<string> Names { get; } = Array.AsReadOnly(new string[13]
		{
			"Tempest_Blizzard", "Tempest_Storm", "Tempest_LightningStorm", "Tempest_Fog", "Tempest_AshStorm", "Tempest_MeteorShower", "Tempest_Whiteout", "Misty", "Snow", "LightRain",
			"Ashlands_misty", "Ashlands_ashrain", "Twilight_Snow"
		});

		public static IReadOnlyList<string> EventEnvironments { get; } = Array.AsReadOnly(new string[7] { "Tempest_Blizzard", "Tempest_Storm", "Tempest_LightningStorm", "Tempest_Fog", "Tempest_AshStorm", "Tempest_MeteorShower", "Tempest_Whiteout" });

		public static IReadOnlyList<string> FreezingEnvironments { get; } = Array.AsReadOnly(new string[2] { "Tempest_Blizzard", "Tempest_Whiteout" });

		public static IReadOnlyList<(string Name, string Source, bool Dry)> Clones { get; } = Array.AsReadOnly(new(string, string, bool)[7]
		{
			("Tempest_Blizzard", "SnowStorm", false),
			("Tempest_Storm", "ThunderStorm", false),
			("Tempest_LightningStorm", "ThunderStorm", true),
			("Tempest_Fog", "Misty", false),
			("Tempest_AshStorm", "Ashlands_storm", false),
			("Tempest_MeteorShower", "Ashlands_meteorshower", false),
			("Tempest_Whiteout", "Twilight_SnowStorm", false)
		});

		public static bool Whiteout(EventKind kind, WeatherBiome biome)
		{
			if (kind == EventKind.Blizzard)
			{
				return biome == WeatherBiome.DeepNorth;
			}
			return false;
		}

		public static string EventEnvironment(EventKind kind)
		{
			return kind switch
			{
				EventKind.Blizzard => "Tempest_Blizzard", 
				EventKind.LightningStorm => "Tempest_LightningStorm", 
				EventKind.DenseFog => "Tempest_Fog", 
				EventKind.AshStorm => "Tempest_AshStorm", 
				EventKind.MeteorShower => "Tempest_MeteorShower", 
				_ => "Tempest_Storm", 
			};
		}

		public static string EventEnvironment(TempestEvent e)
		{
			return EventEnvironment(e.Kind);
		}

		public static string EventEnvironment(EventKind kind, WeatherBiome biome)
		{
			if (!Whiteout(kind, biome))
			{
				return EventEnvironment(kind);
			}
			return "Tempest_Whiteout";
		}

		public static IReadOnlyList<CloneStyle> Styles(string name)
		{
			switch (name)
			{
			case "Tempest_LightningStorm":
				return new CloneStyle[1] { CloneStyle.Dry };
			case "Tempest_Fog":
				return new CloneStyle[2]
				{
					CloneStyle.DenseFog,
					CloneStyle.VisualOnly
				};
			case "Tempest_AshStorm":
			case "Tempest_MeteorShower":
				return new CloneStyle[1] { CloneStyle.VisualOnly };
			case "Tempest_Whiteout":
				return new CloneStyle[2]
				{
					CloneStyle.Whiteout,
					CloneStyle.VisualOnly
				};
			default:
				return new CloneStyle[1];
			}
		}

		public static IReadOnlyList<string> SourceNames(string clone)
		{
			foreach (var clone2 in Clones)
			{
				if (clone2.Name == clone)
				{
					return new string[1] { clone2.Source };
				}
			}
			return Array.Empty<string>();
		}

		public static bool IsEventEnvironment(string? name)
		{
			if (name == null)
			{
				return false;
			}
			foreach (string eventEnvironment in EventEnvironments)
			{
				if (string.Equals(eventEnvironment, name, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsRainEffect(string? name)
		{
			if (name != null)
			{
				return name.IndexOf("rain", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		public static string Source(EventKind kind)
		{
			string text = EventEnvironment(kind);
			foreach (var clone in Clones)
			{
				if (clone.Name == text)
				{
					return clone.Source;
				}
			}
			throw new ArgumentException("Unknown kind.", "kind");
		}

		public static string? Light(EventKind kind)
		{
			return kind switch
			{
				EventKind.Blizzard => "Snow", 
				EventKind.Thunderstorm => "LightRain", 
				EventKind.AshStorm => "Ashlands_ashrain", 
				EventKind.MeteorShower => null, 
				_ => "Misty", 
			};
		}

		public static string? Light(EventKind kind, WeatherBiome biome)
		{
			if (!Whiteout(kind, biome))
			{
				return Light(kind);
			}
			return "Twilight_Snow";
		}

		public static string? Warning(EventKind kind)
		{
			return kind switch
			{
				EventKind.AshStorm => "Ashlands_misty", 
				EventKind.MeteorShower => null, 
				_ => "Misty", 
			};
		}

		public static string? For(TempestEvent? e, double now, WeatherBiome biome, bool gameForced)
		{
			if (e == null || gameForced || !e.Affects(biome))
			{
				return null;
			}
			PhaseState phaseState = Timeline.At(e, now);
			switch (phaseState.Phase)
			{
			case EventPhase.Warning:
				if (!(phaseState.SecondsLeft > 60.0))
				{
					return Light(e.Kind, biome);
				}
				return Warning(e.Kind);
			case EventPhase.Active:
				return EventEnvironment(e.Kind, biome);
			case EventPhase.Clearing:
				return Light(e.Kind, biome);
			default:
				return null;
			}
		}

		public static (bool Freezing, bool Cold) Flags(FreezeLevel level)
		{
			return level switch
			{
				FreezeLevel.Freezing => (Freezing: true, Cold: true), 
				FreezeLevel.Cold => (Freezing: false, Cold: true), 
				_ => (Freezing: false, Cold: false), 
			};
		}

		public static bool ClearsPersonalOverride(TempestEvent? e, double now, WeatherBiome biome)
		{
			if (e != null && e.Affects(biome))
			{
				return Timeline.At(e, now).Phase != EventPhase.Idle;
			}
			return false;
		}
	}
	public static class SeasonalEnvironments
	{
		private static readonly Dictionary<string, string> Bases = Build();

		private static readonly string[] Suffixes = new string[4] { "", " Summer", " Fall", " Winter" };

		private static readonly Dictionary<string, string?[]> Variants = BuildVariants();

		private static Dictionary<string, string?[]> BuildVariants()
		{
			Dictionary<string, string[]> dictionary = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, string> basis in Bases)
			{
				if (!dictionary.TryGetValue(basis.Value, out var value))
				{
					dictionary.Add(basis.Value, value = new string[4]);
				}
				for (int i = 1; i <= 3; i++)
				{
					if (basis.Key.EndsWith(Suffixes[i], StringComparison.Ordinal))
					{
						value[i] = basis.Key;
					}
				}
			}
			return dictionary;
		}

		private static Dictionary<string, string> Build()
		{
			Dictionary<string, string> result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Add(" Summer", new string[7] { "Clear", "Misty", "DeepForest Mist", "Mistlands_clear", "Heath clear", "SwampRain", "Swamp" });
			Add(" Fall", new string[2] { "ThunderStorm", "SwampRain" });
			Add(" Winter", new string[14]
			{
				"Rain", "LightRain", "ThunderStorm", "Clear", "Misty", "DeepForest Mist", "SwampRain", "Mistlands_clear", "Mistlands_rain", "Mistlands_thunder",
				"Heath clear", "Snow", "SnowStorm", "Darklands_dark"
			});
			return result;
			void Add(string suffix, params string[] names)
			{
				foreach (string text in names)
				{
					result.Add(text + suffix, text);
				}
			}
		}

		public static string BaseName(string name)
		{
			if (name == null || !Bases.TryGetValue(name, out string value))
			{
				return name;
			}
			return value;
		}

		public static string? ForSeason(string? name, int season, Func<string, bool> exists)
		{
			if (string.IsNullOrEmpty(name) || season < 1 || season > 3 || EnvironmentPlan.IsEventEnvironment(name))
			{
				return name;
			}
			if (Variants.TryGetValue(BaseName(name), out string[] value))
			{
				string text = value[season];
				if (text != null && exists(text))
				{
					return text;
				}
			}
			return name;
		}
	}
	public readonly struct SeasonReading
	{
		public int Season { get; }

		public bool Effects { get; }

		public bool Available { get; }

		private SeasonReading(int season, bool effects)
		{
			Season = season;
			Effects = effects;
			Available = true;
		}

		public static bool TryRead(string? facts, out SeasonReading reading)
		{
			reading = default(SeasonReading);
			if (string.IsNullOrEmpty(facts) || facts.Length > 16384)
			{
				return false;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			string[] array = facts.Split(';');
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num <= 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num);
				if (!(text2 != "season") || !(text2 != "effects") || !(text2 != "day") || !(text2 != "length") || !(text2 != "doy") || !(text2 != "year"))
				{
					if (dictionary.ContainsKey(text2) || !int.TryParse(text.Substring(num + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						return false;
					}
					dictionary.Add(text2, result);
				}
			}
			if (!dictionary.TryGetValue("season", out var value) || value < 0 || value > 3 || !dictionary.TryGetValue("effects", out var value2) || value2 < 0 || value2 > 1 || !dictionary.TryGetValue("length", out var value3) || value3 <= 0 || !dictionary.TryGetValue("day", out var value4) || value4 < 0 || value4 > value3 || !dictionary.TryGetValue("year", out var value5) || value5 < value3 || !dictionary.TryGetValue("doy", out var value6) || value6 < 0 || value6 > value5)
			{
				return false;
			}
			reading = new SeasonReading(value, value2 == 1);
			return true;
		}
	}
	public sealed class SeasonFactsReader
	{
		private readonly Func<Func<string>?> resolve;

		private double nextRead = double.NegativeInfinity;

		public SeasonReading Reading { get; private set; }

		public SeasonFactsReader(Func<Func<string>?> resolver)
		{
			resolve = resolver ?? throw new ArgumentNullException("resolver");
		}

		public bool Poll(double now)
		{
			if (double.IsNaN(now) || double.IsInfinity(now) || now < nextRead)
			{
				return false;
			}
			nextRead = now + 1.0;
			SeasonReading reading = default(SeasonReading);
			try
			{
				SeasonReading.TryRead(resolve()?.Invoke(), out reading);
			}
			catch (Exception)
			{
				reading = default(SeasonReading);
			}
			bool result = Reading.Available != reading.Available || Reading.Season != reading.Season || Reading.Effects != reading.Effects;
			Reading = reading;
			return result;
		}

		public void Reset()
		{
			Reading = default(SeasonReading);
			nextRead = double.NegativeInfinity;
		}
	}
	public sealed class SeasonalWeights
	{
		private readonly Dictionary<string, float> values;

		public SeasonalWeights(string? text)
		{
			values = Parse(text);
		}

		private static Dictionary<string, float> Parse(string? text)
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);
			string[] array = (text ?? "").Split(',');
			foreach (string text2 in array)
			{
				int num = text2.IndexOf('=');
				if (num >= 1)
				{
					string text3 = text2.Substring(0, num).Trim();
					if (text3.Length != 0 && text3.IndexOf(';') < 0 && text3.IndexOf('\n') < 0 && text3.IndexOf('\r') < 0 && float.TryParse(text2.Substring(num + 1), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && !float.IsNaN(result) && !float.IsInfinity(result) && !(result < 0f) && !(result > 4f))
					{
						dictionary[text3] = result;
					}
				}
			}
			return dictionary;
		}

		public static string Normalize(string? text)
		{
			return string.Join(", ", from p in Parse(text)
				select p.Key + "=" + p.Value.ToString("R", CultureInfo.InvariantCulture));
		}

		public float Multiplier(string? name)
		{
			if (string.IsNullOrEmpty(name) || name.IndexOf("clear", StringComparison.OrdinalIgnoreCase) >= 0 || EnvironmentPlan.IsEventEnvironment(name))
			{
				return 1f;
			}
			string text = SeasonalEnvironments.BaseName(name);
			WeatherSwitch weatherSwitch = WeatherSwitches.Find(text);
			if (weatherSwitch != null && weatherSwitch.Group != SwitchGroup.World)
			{
				return 1f;
			}
			if (values.TryGetValue(name, out var value))
			{
				return value;
			}
			if (!values.TryGetValue(text, out var value2))
			{
				return 1f;
			}
			return value2;
		}
	}
	[Flags]
	public enum HazardEffects
	{
		None = 0,
		Shock = 1,
		Burning = 2
	}
	public static class StormHazards
	{
		public const double RefreshSeconds = 1.0;

		public const string SerialKey = "Tempest_HazardSerial";

		public const string UntilKey = "Tempest_HazardUntil";

		public const double AshSeconds = 5.0;

		public static bool Live(int strikeSerial, double until, TempestEvent? current, double now)
		{
			if (current != null && EventKinds.Lightning(current.Kind) && strikeSerial == current.Serial && now >= current.ActiveStart && now < current.ClearingStart)
			{
				return now < until;
			}
			return false;
		}

		public static bool Inside(float dx, float dy, float dz, float radius)
		{
			if (radius > 0f && !float.IsNaN(dx + dy + dz) && dx * dx + dz * dz <= radius * radius)
			{
				return Math.Abs(dy) <= radius;
			}
			return false;
		}

		public static bool Due(double last, double now)
		{
			if (!(last < 0.0) && !(now < last))
			{
				return now - last >= 1.0;
			}
			return true;
		}

		public static bool Affects(bool enabled, bool dead, bool godMode, bool ghostMode)
		{
			if (enabled && !dead && !godMode)
			{
				return !ghostMode;
			}
			return false;
		}

		public static HazardEffects Effects(bool startsFires, bool raining)
		{
			return (HazardEffects)(1 | ((startsFires && !raining) ? 2 : 0));
		}

		public static (float Lightning, float Fire) Damage(HazardEffects effects, float damage)
		{
			if (float.IsNaN(damage) || damage <= 0f)
			{
				return (Lightning: 0f, Fire: 0f);
			}
			if ((effects & HazardEffects.Burning) == 0)
			{
				return (Lightning: damage, Fire: 0f);
			}
			return (Lightning: damage / 2f, Fire: damage / 2f);
		}

		public static bool AddBurning(HazardEffects effects, bool hasBurning, bool dead)
		{
			if ((effects & HazardEffects.Burning) != HazardEffects.None && !hasBurning)
			{
				return !dead;
			}
			return false;
		}

		public static bool AshBurnEnded(int burnedSerial, TempestEvent? current, double now, bool enabled)
		{
			if (burnedSerial != 0)
			{
				if (enabled && current != null && current.Serial == burnedSerial && !(now < current.ActiveStart))
				{
					return now >= current.ClearingStart;
				}
				return true;
			}
			return false;
		}

		public static bool AshAddBurning(bool hasBurning, bool dead)
		{
			return AddBurning(HazardEffects.Burning, hasBurning, dead);
		}

		public static bool AshBurns(TempestEvent? current, double now, WeatherBiome biome, bool forced, bool enabled, bool dead, bool godMode, bool ghostMode, bool interior, bool underRoof)
		{
			if (current != null && current.Kind == EventKind.AshStorm && !forced && current.Affects(biome) && Timeline.At(current, now).Phase == EventPhase.Active && Affects(enabled, dead, godMode, ghostMode) && !interior)
			{
				return !underRoof;
			}
			return false;
		}

		public static bool AshDue(double last, double now)
		{
			if (!(last < 0.0) && !(now < last))
			{
				return now - last >= 5.0;
			}
			return true;
		}

		public static float AshDamage(float damage)
		{
			if (!float.IsNaN(damage) && !(damage <= 0f))
			{
				return damage;
			}
			return 0f;
		}

		public static long UntilMilliseconds(double now, float lingerSeconds)
		{
			return (long)Math.Round((now + (double)Math.Max(0f, float.IsNaN(lingerSeconds) ? 0f : lingerSeconds)) * 1000.0);
		}
	}
	[Flags]
	public enum StrikeEffects
	{
		None = 0,
		HurtsPlayers = 1,
		StartsFires = 2,
		HitsTrees = 4
	}
	public readonly struct StrikeOrder : IEquatable<StrikeOrder>
	{
		public const string Prefix = "s1";

		public const int MaximumLength = 256;

		public const float MaximumCoordinate = 100000f;

		public const float MaximumDamage = 200f;

		private const double MaximumTime = 1000000000000.0;

		private const int FieldCount = 8;

		public int Serial { get; }

		public long PlayerId { get; }

		public double Time { get; }

		public float X { get; }

		public float Z { get; }

		public float Damage { get; }

		public StrikeEffects Effects { get; }

		public string Id => Serial.ToString(CultureInfo.InvariantCulture) + ":" + PlayerId.ToString(CultureInfo.InvariantCulture) + ":" + Num(Time);

		public StrikeOrder(int serial, long playerId, double time, float x, float z, float damage, StrikeEffects effects)
		{
			Serial = serial;
			PlayerId = playerId;
			Time = time;
			X = x;
			Z = z;
			Damage = damage;
			Effects = effects;
		}

		public string Encode()
		{
			return string.Join(";", "s1", Serial.ToString(CultureInfo.InvariantCulture), PlayerId.ToString(CultureInfo.InvariantCulture), Num(Time), Num(X), Num(Z), Num(Damage), ((int)Effects).ToString(CultureInfo.InvariantCulture));
		}

		public static bool TryDecode(string? text, out StrikeOrder order)
		{
			order = default(StrikeOrder);
			if (string.IsNullOrEmpty(text) || text.Length > 256)
			{
				return false;
			}
			string[] array = text.Split(';');
			if (array.Length != 8 || array[0] != "s1")
			{
				return false;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			if (!int.TryParse(array[1], NumberStyles.AllowLeadingSign, invariantCulture, out var result) || result <= 0)
			{
				return false;
			}
			if (!long.TryParse(array[2], NumberStyles.AllowLeadingSign, invariantCulture, out var result2) || result2 == 0L)
			{
				return false;
			}
			if (!double.TryParse(array[3], NumberStyles.Float, invariantCulture, out var result3) || !Finite(result3) || result3 < 0.0 || result3 > 1000000000000.0)
			{
				return false;
			}
			if (!float.TryParse(array[4], NumberStyles.Float, invariantCulture, out var result4) || !Finite(result4) || Math.Abs(result4) > 100000f)
			{
				return false;
			}
			if (!float.TryParse(array[5], NumberStyles.Float, invariantCulture, out var result5) || !Finite(result5) || Math.Abs(result5) > 100000f)
			{
				return false;
			}
			if (!float.TryParse(array[6], NumberStyles.Float, invariantCulture, out var result6) || !Finite(result6) || result6 < 0f || result6 > 200f)
			{
				return false;
			}
			if (!int.TryParse(array[7], NumberStyles.AllowLeadingSign, invariantCulture, out var result7) || result7 < 0 || result7 > 7)
			{
				return false;
			}
			order = new StrikeOrder(result, result2, result3, result4, result5, result6, (StrikeEffects)result7);
			return true;
		}

		public bool Equals(StrikeOrder other)
		{
			if (Serial == other.Serial && PlayerId == other.PlayerId && Time.Equals(other.Time) && X.Equals(other.X) && Z.Equals(other.Z) && Damage.Equals(other.Damage))
			{
				return Effects == other.Effects;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((((Serial * 397) ^ PlayerId.GetHashCode()) * 397) ^ Time.GetHashCode()) * 397) ^ (int)Effects;
		}

		public override string ToString()
		{
			return Encode();
		}

		private static bool Finite(double v)
		{
			if (!double.IsNaN(v))
			{
				return !double.IsInfinity(v);
			}
			return false;
		}

		private static string Num(double v)
		{
			return v.ToString("R", CultureInfo.InvariantCulture).ToLowerInvariant();
		}

		private static string Num(float v)
		{
			return v.ToString("R", CultureInfo.InvariantCulture).ToLowerInvariant();
		}
	}
	public enum StrikeVerdict
	{
		Accepted,
		OtherPlayer,
		NoEvent,
		OtherEvent,
		NotActive,
		Stale,
		Forced
	}
	public static class StrikeOrders
	{
		public const double AcceptWindowSeconds = 10.0;

		public const double TelegraphSeconds = 1.0;

		public static IReadOnlyList<StrikeOrder> Plan(TempestEvent e, long playerId, float playerX, float playerZ, int perMinute, float damage, StrikeEffects effects, double from, double to, Func<float, float, bool> spared)
		{
			if (e == null)
			{
				throw new ArgumentNullException("e");
			}
			if (spared == null)
			{
				throw new ArgumentNullException("spared");
			}
			float damage2 = (float.IsNaN(damage) ? 0f : Math.Max(0f, Math.Min(200f, damage)));
			List<StrikeOrder> list = new List<StrikeOrder>();
			foreach (PlannedStrike item in StrikePlanner.Due(e, playerId, perMinute, from, to))
			{
				float num = playerX + item.X;
				float num2 = playerZ + item.Z;
				if (!(Math.Abs(num) > 100000f) && !(Math.Abs(num2) > 100000f) && !spared(num, num2))
				{
					list.Add(new StrikeOrder(e.Serial, playerId, item.Time, num, num2, damage2, effects));
				}
			}
			return list;
		}

		public static StrikeVerdict Accept(StrikeOrder order, TempestEvent? current, long localPlayerId, double now, bool forced)
		{
			if (order.PlayerId != localPlayerId)
			{
				return StrikeVerdict.OtherPlayer;
			}
			if (current == null)
			{
				return StrikeVerdict.NoEvent;
			}
			if (current.Serial != order.Serial)
			{
				return StrikeVerdict.OtherEvent;
			}
			if (!EventKinds.Strikes(current.Kind) || order.Time < current.ActiveStart - 1.0 || order.Time >= current.ClearingStart)
			{
				return StrikeVerdict.NotActive;
			}
			if (Math.Abs(now - order.Time) > 10.0)
			{
				return StrikeVerdict.Stale;
			}
			if (now < current.ActiveStart || now >= current.ClearingStart)
			{
				return StrikeVerdict.NotActive;
			}
			if (forced)
			{
				return StrikeVerdict.Forced;
			}
			return StrikeVerdict.Accepted;
		}
	}
	public sealed class StrikeLedger
	{
		private readonly int capacity;

		private readonly Queue<string> order = new Queue<string>();

		private readonly HashSet<string> seen = new HashSet<string>(StringComparer.Ordinal);

		public int Count => seen.Count;

		public StrikeLedger(int capacity)
		{
			if (capacity <= 0)
			{
				throw new ArgumentOutOfRangeException("capacity");
			}
			this.capacity = capacity;
		}

		public bool Admit(string id)
		{
			if (id == null || seen.Contains(id))
			{
				return false;
			}
			if (order.Count >= capacity)
			{
				seen.Remove(order.Dequeue());
			}
			order.Enqueue(id);
			seen.Add(id);
			return true;
		}

		public void Clear()
		{
			order.Clear();
			seen.Clear();
		}
	}
	public enum StrikeTarget
	{
		Player,
		Creature,
		Tree,
		Piece,
		Other
	}
	public static class StrikeTargets
	{
		public static bool Allow(StrikeEffects effects, StrikeTarget target)
		{
			return target switch
			{
				StrikeTarget.Player => (effects & StrikeEffects.HurtsPlayers) != 0, 
				StrikeTarget.Tree => (effects & StrikeEffects.HitsTrees) != 0, 
				StrikeTarget.Piece => false, 
				_ => true, 
			};
		}

		public static StrikeEffects InWeather(StrikeEffects effects, bool raining)
		{
			if (!raining)
			{
				return effects;
			}
			return effects & ~StrikeEffects.StartsFires;
		}

		public static (float Lightning, float Fire) Damage(float damage, StrikeEffects effects)
		{
			if (float.IsNaN(damage) || damage <= 0f)
			{
				return (Lightning: 0f, Fire: 0f);
			}
			if ((effects & StrikeEffects.StartsFires) == 0)
			{
				return (Lightning: damage, Fire: 0f);
			}
			return (Lightning: damage / 2f, Fire: damage / 2f);
		}

		public static bool CanIgnite(StrikeEffects effects, StrikeTarget target, bool insideWard, bool insideShield)
		{
			if ((effects & StrikeEffects.StartsFires) == 0 || insideWard || insideShield)
			{
				return false;
			}
			return target switch
			{
				StrikeTarget.Tree => (effects & StrikeEffects.HitsTrees) != 0, 
				StrikeTarget.Other => true, 
				_ => false, 
			};
		}

		public static StrikeEffects Effects(bool hurtsPlayers, bool startsFires, bool hitsTrees)
		{
			return (StrikeEffects)((hurtsPlayers ? 1 : 0) | (startsFires ? 2 : 0) | (hitsTrees ? 4 : 0));
		}
	}
	public readonly struct PlannedStrike
	{
		public double Second { get; }

		public float X { get; }

		public float Z { get; }

		public double Time { get; }

		public PlannedStrike(double second, float x, float z, double time)
		{
			Second = second;
			X = x;
			Z = z;
			Time = time;
		}
	}
	public static class StrikePlanner
	{
		public const float MinimumDistance = 15f;

		public const float MaximumDistance = 60f;

		public const int MaximumPerMinute = 30;

		public static IReadOnlyList<PlannedStrike> ForMinute(int eventSeed, long minute, long playerId, int perMinute)
		{
			int num = Math.Max(0, Math.Min(30, perMinute));
			List<PlannedStrike> list = new List<PlannedStrike>(num);
			ulong a = (uint)eventSeed;
			ulong b = (ulong)((minute * 1099511628211L) ^ playerId);
			for (int i = 0; i < num; i++)
			{
				double second = SeededRandom.Unit(a, b, (ulong)(i * 3 + 1)) * 60.0;
				double num2 = SeededRandom.Unit(a, b, (ulong)(i * 3 + 2)) * 2.0 * Math.PI;
				double num3 = SeededRandom.Unit(a, b, (ulong)(i * 3 + 3));
				double num4 = Math.Sqrt(225.0 + num3 * 3375.0);
				list.Add(new PlannedStrike(second, (float)(Math.Cos(num2) * num4), (float)(Math.Sin(num2) * num4), 0.0));
			}
			return list.OrderBy((PlannedStrike s) => s.Second).ToList();
		}

		public static int Rate(TempestEvent e, int perMinute, float lightningMultiplier)
		{
			if (perMinute <= 0)
			{
				return 0;
			}
			if (e == null || !e.Dry || float.IsNaN(lightningMultiplier))
			{
				return Math.Min(30, perMinute);
			}
			float num = Math.Max(1f, Math.Min(5f, lightningMultiplier));
			return (int)Math.Min(30.0, Math.Round((float)perMinute * num, MidpointRounding.AwayFromZero));
		}

		public static IReadOnlyList<PlannedStrike> Due(TempestEvent e, long playerId, int perMinute, double from, double to)
		{
			if (e == null)
			{
				throw new ArgumentNullException("e");
			}
			List<PlannedStrike> list = new List<PlannedStrike>();
			if (!EventKinds.Strikes(e.Kind) || !(to > from))
			{
				return list;
			}
			double num = Math.Max(from, e.ActiveStart - 1.0);
			double num2 = Math.Min(to, e.ClearingStart);
			if (!(num2 > num))
			{
				return list;
			}
			long val = (long)Math.Floor((num - e.ActiveStart) / 60.0);
			long num3 = (long)Math.Floor((num2 - e.ActiveStart) / 60.0);
			for (long num4 = Math.Max(0L, val); num4 <= num3; num4++)
			{
				foreach (PlannedStrike item in ForMinute(e.Seed, num4, playerId, perMinute))
				{
					double num5 = e.ActiveStart + (double)(num4 * 60) + item.Second;
					if (num5 > from && num5 <= to && num5 < e.ClearingStart)
					{
						list.Add(new PlannedStrike(item.Second, item.X, item.Z, num5));
					}
				}
			}
			return list;
		}
	}
	public readonly struct SparedArea
	{
		public float X { get; }

		public float Z { get; }

		public float Radius { get; }

		public SparedArea(float x, float z, float radius)
		{
			X = x;
			Z = z;
			Radius = radius;
		}
	}
	public readonly struct PiecePoint
	{
		public float X { get; }

		public float Z { get; }

		public PiecePoint(float x, float z)
		{
			X = x;
			Z = z;
		}
	}
	public static class BaseExclusion
	{
		public static bool Spared(float x, float z, IEnumerable<SparedArea> areas, IEnumerable<PiecePoint> pieces, float clearance)
		{
			foreach (SparedArea item in areas ?? Enumerable.Empty<SparedArea>())
			{
				if (Within(x, z, item.X, item.Z, item.Radius))
				{
					return true;
				}
			}
			if (!(clearance > 0f))
			{
				return false;
			}
			foreach (PiecePoint item2 in pieces ?? Enumerable.Empty<PiecePoint>())
			{
				if (Within(x, z, item2.X, item2.Z, clearance))
				{
					return true;
				}
			}
			return false;
		}

		private static bool Within(float x, float z, float cx, float cz, float r)
		{
			float num = x - cx;
			float num2 = z - cz;
			return num * num + num2 * num2 <= r * r;
		}
	}
	public enum SwitchGroup
	{
		World,
		Boss,
		Dungeon,
		Raid
	}
	public sealed class WeatherSwitch
	{
		public SwitchGroup Group { get; }

		public string Environment { get; }

		public string Key { get; }

		public string Description { get; }

		public string Section => "Weather Filter - " + Group;

		public string SourceSection => "Weather Events - " + Group;

		internal WeatherSwitch(SwitchGroup group, string environment, string key, string description)
		{
			Group = group;
			Environment = environment;
			Key = key;
			Description = description;
		}
	}
	public static class WeatherSwitches
	{
		private static readonly Dictionary<string, WeatherSwitch> ByEnvironment = All.ToDictionary<WeatherSwitch, string>((WeatherSwitch s) => s.Environment, StringComparer.OrdinalIgnoreCase);

		public static IReadOnlyList<WeatherSwitch> All { get; } = Array.AsReadOnly(new WeatherSwitch[45]
		{
			new WeatherSwitch(SwitchGroup.World, "Misty", "Enable Misty Weather", "Enables dense fog weather in Meadows, Black Forest, Plains, and Ocean."),
			new WeatherSwitch(SwitchGroup.World, "DeepForest Mist", "Enable Deep Forest Mist Weather", "Enables mist and fog weather in Black Forest."),
			new WeatherSwitch(SwitchGroup.World, "Rain", "Enable Rain Weather", "Enables standard rain in Meadows, Black Forest, Plains, and Ocean."),
			new WeatherSwitch(SwitchGroup.World, "LightRain", "Enable Light Rain Weather", "Enables light rain and drizzle in Meadows, Plains, and Ocean."),
			new WeatherSwitch(SwitchGroup.World, "ThunderStorm", "Enable Thunderstorm Weather", "Enables heavy thunderstorms and sea storms in Meadows, Plains, and Ocean."),
			new WeatherSwitch(SwitchGroup.World, "SwampRain", "Enable Swamp Rain Weather", "Enables continuous rain and gloom in Swamp."),
			new WeatherSwitch(SwitchGroup.World, "Snow", "Enable Snow Weather", "Enables snowfall in Mountain and Deep North."),
			new WeatherSwitch(SwitchGroup.World, "SnowStorm", "Enable Snowstorm Weather", "Enables snowstorms and blizzards in Mountain and Deep North."),
			new WeatherSwitch(SwitchGroup.World, "Twilight_Snow", "Enable Twilight Snow Weather", "Enables twilight snowfall in the Deep North."),
			new WeatherSwitch(SwitchGroup.World, "Twilight_SnowStorm", "Enable Twilight Snowstorm Weather", "Enables twilight snowstorms in the Deep North."),
			new WeatherSwitch(SwitchGroup.World, "Mistlands_rain", "Enable Mistlands Rain Weather", "Enables rainfall in Mistlands."),
			new WeatherSwitch(SwitchGroup.World, "Mistlands_thunder", "Enable Mistlands Thunder Weather", "Enables thunderstorms in Mistlands."),
			new WeatherSwitch(SwitchGroup.World, "Ashlands_misty", "Enable Ashlands Mist Weather", "Enables foggy mist weather in Ashlands."),
			new WeatherSwitch(SwitchGroup.World, "Ashlands_ashrain", "Enable Ashlands Ash Rain Weather", "Enables ash rain in Ashlands."),
			new WeatherSwitch(SwitchGroup.World, "Ashlands_CinderRain", "Enable Ashlands Cinder Rain Weather", "Enables cinder rain in Ashlands."),
			new WeatherSwitch(SwitchGroup.World, "Ashlands_storm", "Enable Ashlands Storm Weather", "Enables heavy storms in Ashlands."),
			new WeatherSwitch(SwitchGroup.World, "Ashlands_meteorshower", "Enable Ashlands Meteor Shower Weather", "Enables meteor showers in Ashlands."),
			new WeatherSwitch(SwitchGroup.World, "Ashlands_SeaStorm", "Enable Ashlands Sea Storm Weather", "Enables boiling sea storms in Ashlands."),
			new WeatherSwitch(SwitchGroup.World, "Ashrain", "Enable Legacy Ash Rain Weather", "Enables the older ash rain weather in Ashlands. Off: Ashlands never picks it."),
			new WeatherSwitch(SwitchGroup.World, "Darklands_dark", "Enable Darklands Dark Weather", "Enables darklands environmental darkness."),
			new WeatherSwitch(SwitchGroup.World, "nofogts", "Enable Internal NoFog Weather", "Enables the game's fog-free thunderstorm variant. Off: the game never picks it."),
			new WeatherSwitch(SwitchGroup.Boss, "Eikthyr", "Enable Eikthyr Weather", "Enables storm and lightning weather during Eikthyr boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "Eikthyr_no_lightning", "Enable Eikthyr No Lightning Weather", "Enables storm without lightning during Eikthyr boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "GDKing", "Enable The Elder Weather", "Enables overcast root weather during The Elder boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "Bonemass", "Enable Bonemass Weather", "Enables murky swamp weather during Bonemass boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "Moder", "Enable Moder Weather", "Enables freezing blizzard weather during Moder boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "GoblinKing", "Enable Yagluth Weather", "Enables fiery atmospheric weather during Yagluth boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "Queen", "Enable The Queen Weather", "Enables infested chamber weather during The Queen boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "Fader", "Enable Fader Weather", "Enables ash vortex weather during Fader boss fight."),
			new WeatherSwitch(SwitchGroup.Boss, "DN_Bossroom", "Enable Deep North Boss Room Weather", "Enables Deep North boss arena weather."),
			new WeatherSwitch(SwitchGroup.Dungeon, "Crypt", "Enable Burial Chambers Weather", "Enables interior crypt gloom in Black Forest Burial Chambers."),
			new WeatherSwitch(SwitchGroup.Dungeon, "SunkenCrypt", "Enable Sunken Crypt Weather", "Enables interior wet gloom in Swamp Sunken Crypts."),
			new WeatherSwitch(SwitchGroup.Dungeon, "Caves", "Enable Mountain Caves Weather", "Enables interior mist and cold in Mountain Frost Caves."),
			new WeatherSwitch(SwitchGroup.Dungeon, "CavesHildir", "Enable Hildir Frost Caves Weather", "Enables interior mist in Hildir Mountain Caves."),
			new WeatherSwitch(SwitchGroup.Dungeon, "CryptHildir", "Enable Hildir Sunken Crypt Weather", "Enables interior mist in Hildir Sunken Crypts."),
			new WeatherSwitch(SwitchGroup.Dungeon, "InfectedMine", "Enable Infected Mine Weather", "Enables interior mist and spores in Mistlands Infected Mines."),
			new WeatherSwitch(SwitchGroup.Raid, "Ghosts", "Enable Ghosts Raid Weather", "Enables ghostly mist during ghost raid encounters."),
			new WeatherSwitch(SwitchGroup.Raid, "JotunInvasion_meadows", "Enable Meadows Invasion Raid Weather", "Enables atmospheric distortion during Meadows Jotun invasions."),
			new WeatherSwitch(SwitchGroup.Raid, "JotunInvasion_blackforest", "Enable Black Forest Invasion Raid Weather", "Enables atmospheric distortion during Black Forest Jotun invasions."),
			new WeatherSwitch(SwitchGroup.Raid, "JotunInvasion_swamp", "Enable Swamp Invasion Raid Weather", "Enables atmospheric distortion during Swamp Jotun invasions."),
			new WeatherSwitch(SwitchGroup.Raid, "JotunInvasion_mountain", "Enable Mountain Invasion Raid Weather", "Enables atmospheric distortion during Mountain Jotun invasions."),
			new WeatherSwitch(SwitchGroup.Raid, "JotunInvasion_plains", "Enable Plains Invasion Raid Weather", "Enables atmospheric distortion during Plains Jotun invasions."),
			new WeatherSwitch(SwitchGroup.Raid, "JotunInvasion_mistlands", "Enable Mistlands Invasion Raid Weather", "Enables atmospheric distortion during Mistlands Jotun invasions."),
			new WeatherSwitch(SwitchGroup.Raid, "Morkhalla", "Enable Morkhalla Raid Weather", "Enables Morkhalla event weather."),
			new WeatherSwitch(SwitchGroup.Raid, "TheHollow", "Enable The Hollow Raid Weather", "Enables The Hollow event weather.")
		});

		public static WeatherSwitch? Find(string? environment)
		{
			if (environment == null || !ByEnvironment.TryGetValue(environment, out WeatherSwitch value))
			{
				return null;
			}
			return value;
		}
	}
	public sealed class WeatherFilter
	{
		private readonly Func<WeatherSwitch, bool> isOn;

		private readonly HashSet<string> others;

		private readonly SeasonalWeights? seasonal;

		public WeatherFilter(Func<WeatherSwitch, bool> isOn, string? otherDisabled)
			: this(isOn, otherDisabled, null)
		{
		}

		public WeatherFilter(Func<WeatherSwitch, bool> isOn, string? otherDisabled, SeasonalWeights? seasonal)
		{
			this.isOn = isOn ?? throw new ArgumentNullException("isOn");
			others = new HashSet<string>(SplitList(otherDisabled), StringComparer.OrdinalIgnoreCase);
			this.seasonal = seasonal;
		}

		public bool Allows(string? environment)
		{
			if (string.IsNullOrEmpty(environment) || IsClear(environment) || IsTempest(environment))
			{
				return true;
			}
			string text = SeasonalEnvironments.BaseName(environment);
			if (others.Contains(environment) || others.Contains(text))
			{
				return false;
			}
			WeatherSwitch weatherSwitch = WeatherSwitches.Find(text);
			if (weatherSwitch == null || isOn(weatherSwitch))
			{
				return Weight(environment) > 0f;
			}
			return false;
		}

		public float Weight(string? environment)
		{
			return seasonal?.Multiplier(environment) ?? 1f;
		}

		public IReadOnlyList<string> Available(IEnumerable<string> environments, string? fallback)
		{
			List<string> list = (environments ?? Enumerable.Empty<string>()).Where(Allows).ToList();
			if (list.Count == 0 && !string.IsNullOrEmpty(fallback))
			{
				list.Add(fallback);
			}
			return list;
		}

		public string? ForcedOrNull(string? environment)
		{
			if (!string.IsNullOrEmpty(environment) && Allows(environment))
			{
				return environment;
			}
			return null;
		}

		public static string? Fallback(IEnumerable<string>? biomeEnvironments, Func<string, bool> exists, string? defaultEnvironment)
		{
			foreach (string item in biomeEnvironments ?? Enumerable.Empty<string>())
			{
				if (!string.IsNullOrEmpty(item) && IsClear(item) && exists(item))
				{
					return item;
				}
			}
			if (!exists("Clear"))
			{
				return defaultEnvironment;
			}
			return "Clear";
		}

		public static string NormalizeList(string? text)
		{
			return string.Join(", ", SplitList(text));
		}

		private static IEnumerable<string> SplitList(string? text)
		{
			HashSet<string> seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0 && !IsClear(text2) && !IsTempest(text2) && seen.Add(text2))
				{
					yield return text2;
				}
			}
		}

		private static bool IsClear(string name)
		{
			return name.IndexOf("clear", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool IsTempest(string name)
		{
			return EnvironmentPlan.IsEventEnvironment(name);
		}
	}
}
namespace ExtraPotions.Tempest.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 TempestTextKeys
	{
		public const string OffNoCrucible = "off_no_crucible";

		public const string OffNoTempest = "off_no_tempest";

		public const string ImportDone = "import_done";

		public const string ImportPreview = "import_preview";

		public const string ImportUnavailable = "import_unavailable";

		public const string ImportHostOnly = "import_host_only";

		public const string WarningStarted = "warning_started";

		public const string EventStarted = "event_started";

		public const string EventEnded = "event_ended";

		public const string PhaseWarning = "phase_warning";

		public const string PhaseActive = "phase_active";

		public const string PhaseClearing = "phase_clearing";

		public const string BadgeEtaWarning = "badge_eta_warning";

		public const string BadgeEtaActive = "badge_eta_active";

		public const string BadgeEtaClearing = "badge_eta_clearing";

		public const string CommandStatusIdle = "cmd_status_idle";

		public const string CommandStatusEvent = "cmd_status_event";

		public const string CommandStarted = "cmd_started";

		public const string CommandStopped = "cmd_stopped";

		public const string CommandBusy = "cmd_busy";

		public const string CommandNothing = "cmd_nothing";

		public const string CommandNoBiome = "cmd_no_biome";

		public const string CommandCheatOff = "cmd_cheat_off";

		public const string CommandNotAdmin = "cmd_not_admin";

		public const string CommandMischiefDenied = "cmd_mischief_denied";

		public const string CommandRemoteFailed = "cmd_remote_failed";

		public const string CommandSent = "cmd_sent";

		public const string CommandHeadless = "cmd_headless";

		public const string CommandInactive = "cmd_inactive";

		public const string CommandHelp = "cmd_help";

		public const string CommandDryUnsupported = "cmd_dry_unsupported";

		public const string OverrideSet = "override_set";

		public const string OverrideReset = "override_reset";

		public const string OverrideUnknown = "override_unknown";

		public const string OverrideCleared = "override_cleared";

		public const string KindLightningStorm = "kind_lightning_storm";

		public static IReadOnlyList<TextKey> All { get; } = Array.AsReadOnly(new TextKey[46]
		{
			new TextKey("step_aside_events", 1),
			new TextKey("step_aside_filter", 1),
			new TextKey("step_aside_override", 1),
			new TextKey("off_no_crucible", 0),
			new TextKey("off_no_tempest", 0),
			new TextKey("import_done", 2),
			new TextKey("import_preview", 4),
			new TextKey("import_unavailable", 0),
			new TextKey("import_host_only", 0),
			new TextKey("cheat_weather_commands", 0),
			new TextKey("cheat_personal_override", 0),
			new TextKey("kind_blizzard", 0),
			new TextKey("kind_thunderstorm", 0),
			new TextKey("kind_lightning_storm", 0),
			new TextKey("kind_dense_fog", 0),
			new TextKey("kind_ash_storm", 0),
			new TextKey("kind_meteor_shower", 0),
			new TextKey("warning_started", 2),
			new TextKey("event_started", 1),
			new TextKey("event_ended", 1),
			new TextKey("phase_warning", 0),
			new TextKey("phase_active", 0),
			new TextKey("phase_clearing", 0),
			new TextKey("badge_eta_warning", 1),
			new TextKey("badge_eta_active", 1),
			new TextKey("badge_eta_clearing", 1),
			new TextKey("cmd_status_idle", 0),
			new TextKey("cmd_status_event", 3),
			new TextKey("cmd_started", 1),
			new TextKey("cmd_stopped", 1),
			new TextKey("cmd_busy", 0),
			new TextKey("cmd_nothing", 0),
			new TextKey("cmd_no_biome", 1),
			new TextKey("cmd_cheat_off", 0),
			new TextKey("cmd_not_admin", 0),
			new TextKey("cmd_mischief_denied", 0),
			new TextKey("cmd_remote_failed", 1),
			new TextKey("cmd_sent", 0),
			new TextKey("cmd_headless", 0),
			new TextKey("cmd_inactive", 0),
			new TextKey("cmd_help", 0),
			new TextKey("cmd_dry_unsupported", 0),
			new TextKey("override_set", 1),
			new TextKey("override_reset", 0),
			new TextKey("override_unknown", 1),
			new TextKey("override_cleared", 0)
		});

		public static string Kind(EventKind kind)
		{
			return "kind_" + EventKinds.Token(kind);
		}

		public static string Kind(EventKind kind, bool dry)
		{
			if (!dry || kind != EventKind.Thunderstorm)
			{
				return Kind(kind);
			}
			return "kind_lightning_storm";
		}

		public static string Kind(TempestEvent e)
		{
			return Kind(e.Kind, e.Dry);
		}

		public static string Phase(EventPhase phase)
		{
			return phase switch
			{
				EventPhase.Warning => "phase_warning", 
				EventPhase.Active => "phase_active", 
				EventPhase.Clearing => "phase_clearing", 
				_ => throw new ArgumentException("Idle has no phase text.", "phase"), 
			};
		}

		public static string BadgeEta(EventPhase phase)
		{
			return phase switch
			{
				EventPhase.Warning => "badge_eta_warning", 
				EventPhase.Active => "badge_eta_active", 
				EventPhase.Clearing => "badge_eta_clearing", 
				_ => throw new ArgumentException("Idle has no badge countdown.", "phase"), 
			};
		}

		public static long WholeSeconds(double seconds)
		{
			if (double.IsNaN(seconds) || double.IsInfinity(seconds) || seconds < 0.0)
			{
				seconds = 0.0;
			}
			return (long)Math.Ceiling(seconds - 1E-09);
		}

		public static string Countdown(double seconds)
		{
			long num = WholeSeconds(seconds);
			long num2 = num / 3600;
			long num3 = num / 60 % 60;
			long num4 = num % 60;
			if (num2 <= 0)
			{
				return num3 + ":" + num4.ToString("00", CultureInfo.InvariantCulture);
			}
			return num2 + ":" + num3.ToString("00", CultureInfo.InvariantCulture) + ":" + num4.ToString("00", CultureInfo.InvariantCulture);
		}
	}
}
namespace ExtraPotions.Tempest.Integration
{
	public readonly struct BadgeState
	{
		public static BadgeState Hidden => default(BadgeState);

		public bool Visible { get; }

		public EventKind Kind { get; }

		public bool Dry { get; }

		public EventPhase Phase { get; }

		public double SecondsLeft { get; }

		public double Fraction { get; }

		public BadgeState(bool visible, EventKind kind, EventPhase phase, double secondsLeft, double fraction, bool dry = false)
		{
			Dry = dry;
			Visible = visible;
			Kind = kind;
			Phase = phase;
			SecondsLeft = secondsLeft;
			Fraction = fraction;
		}
	}
	public static class Badge
	{
		public static BadgeState For(TempestEvent? e, double now, WeatherBiome localBiome, bool gameForced, bool badgeOn, bool otherHudShows)
		{
			if (e == null || !badgeOn || otherHudShows || gameForced || !e.Affects(localBiome))
			{
				return BadgeState.Hidden;
			}
			PhaseState phaseState = Timeline.At(e, now);
			if (phaseState.Phase == EventPhase.Idle)
			{
				return BadgeState.Hidden;
			}
			int num = ((phaseState.Phase == EventPhase.Warning) ? e.WarningSeconds : ((phaseState.Phase == EventPhase.Active) ? e.ActiveSeconds : e.ClearingSeconds));
			double num2 = Math.Max(0.0, phaseState.SecondsLeft);
			double fraction = ((num > 0) ? Math.Max(0.0, Math.Min(1.0, num2 / (double)num)) : 0.0);
			return new BadgeState(visible: true, e.Kind, phaseState.Phase, num2, fraction, e.Dry);
		}

		public static string Title(BadgeState state, Func<string, string> text)
		{
			if (!state.Visible)
			{
				return "";
			}
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			return text(TempestTextKeys.Kind(state.Kind, state.Dry));
		}

		public static string Detail(BadgeState state, Func<string, string, string> format)
		{
			if (!state.Visible)
			{
				return "";
			}
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			return format(TempestTextKeys.BadgeEta(state.Phase), TempestTextKeys.Countdown(state.SecondsLeft));
		}

		public static string Text(BadgeState state, Func<string, string> text)
		{
			if (!state.Visible)
			{
				return "";
			}
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			return text(TempestTextKeys.Kind(state.Kind, state.Dry)) + " " + text(TempestTextKeys.Phase(state.Phase)) + " " + TempestTextKeys.Countdown(state.SecondsLeft);
		}
	}
	public static class CenterNotice
	{
		public static bool Show(bool warningMessageOn, bool otherHudShows)
		{
			if (warningMessageOn)
			{
				return !otherHudShows;
			}
			return false;
		}
	}
	public sealed class WarningCue
	{
		private int played;

		public bool Observe(TempestEvent? e, double now, WeatherBiome localBiome, bool gameForced)
		{
			if (e == null || e.Serial == played || gameForced || !e.Affects(localBiome))
			{
				return false;
			}
			if (Timeline.At(e, now).Phase != EventPhase.Warning)
			{
				return false;
			}
			played = e.Serial;
			return true;
		}
	}
	public static class WarningSound
	{
		public const string Storm = "sfx_thunder";

		public const string Blizzard = "sfx_Frost_Start";

		public static string For(EventKind kind)
		{
			if (kind != EventKind.Blizzard)
			{
				return "sfx_thunder";
			}
			return "sfx_Frost_Start";
		}

		public static bool Matches(string? prefabName, string wanted)
		{
			if (prefabName != null)
			{
				return string.Equals(prefabName, wanted, StringComparison.Ordinal);
			}
			return false;
		}
	}
	public enum TempestModule
	{
		Events,
		Filter,
		Override
	}
	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 TempestModule Module { get; }

		public IReadOnlyList<string> PluginNames { get; }

		public string ModuleId => Module.ToString().ToLowerInvariant();

		internal ModuleSource(string guid, string name, TempestModule module, params string[] pluginNames)
		{
			Guid = guid;
			Name = name;
			Module = module;
			PluginNames = pluginNames;
		}

		public bool Matches(InstalledPlugin plugin)
		{
			if (!string.Equals(plugin.Guid, Guid, StringComparison.Ordinal))
			{
				return PluginNames.Any((string n) => string.Equals(n, plugin.Name, StringComparison.OrdinalIgnoreCase));
			}
			return true;
		}
	}
	public readonly struct StepAsideNotice
	{
		public TempestModule Module { get; }

		public string SourceName { get; }

		public string SourceGuid { get; }

		public string Key => KeyOf(Module);

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

		public static string KeyOf(TempestModule module)
		{
			return "step_aside_" + module.ToString().ToLowerInvariant();
		}
	}
	public sealed class ModuleStepAsideDecision
	{
		private readonly HashSet<TempestModule> 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<TempestModule>(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(TempestModule module)
		{
			return aside.Contains(module);
		}
	}
	public static class ModuleStepAside
	{
		public static readonly ModuleSource WildWeather = new ModuleSource("com.burks.wildweather", "WildWeather", TempestModule.Events, "Wild Weather", "WildWeather");

		public static readonly ModuleSource NoFogBruh = new ModuleSource("vapok.mods.nofogbruh", "NoFogBruh", TempestModule.Filter);

		public static readonly ModuleSource AdminTool = new ModuleSource("com.icecub.valheimadmintool", "Valheim_Admin_Tool", TempestModule.Override);

		public static IReadOnlyList<ModuleSource> Sources { get; } = Array.AsReadOnly(new ModuleSource[3] { WildWeather, NoFogBruh, AdminTool });

		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 enum NoticeRoute
	{
		Log,
		Journal,
		Kit,
		Native
	}
	public static class NoticeRoutes
	{
		public static NoticeRoute For(bool gameUi, bool kitActive, bool playerWindowOpen)
		{
			if (!gameUi)
			{
				return NoticeRoute.Log;
			}
			if (playerWindowOpen)
			{
				return NoticeRoute.Journal;
			}
			if (!kitActive)
			{
				return NoticeRoute.Native;
			}
			return NoticeRoute.Kit;
		}
	}
	public readonly struct WeatherEventsView : IEquatable<WeatherEventsView>
	{
		public const string Id = "meadworks.weather.events";

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

		public const float MaximumSecondsLeft = 3600f;

		public int Kind { get; }

		public int Phase { get; }

		public float SecondsLeft { get; }

		public int Biomes { get; }

		public bool LocalAffected { get; }

		public int Revision { get; }

		public WeatherEventsView(int kind, int phase, float secondsLeft, int biomes, bool localAffected, int revision)
		{
			Kind = kind;
			Phase = phase;
			SecondsLeft = secondsLeft;
			Biomes = biomes;
			LocalAffected = localAffected;
			Revision = revision;
		}

		public WeatherEventsView WithRevision(int revision)
		{
			return new WeatherEventsView(Kind, Phase, SecondsLeft, Biomes, LocalAffected, revision);
		}

		public static WeatherEventsView Read(TempestEvent? e, double now, WeatherBiome localBiome, bool gameForced)
		{
			if (e == null)
			{
				return default(WeatherEventsView);
			}
			PhaseState phaseState = Timeline.At(e, now);
			if (phaseState.Phase == EventPhase.Idle)
			{
				return default(WeatherEventsView);
			}
			float secondsLeft = (float)Math.Max(0.0, Math.Min(3600.0, phaseState.SecondsLeft));
			if (EventKinds.Extended(e.Kind))
			{
				return default(WeatherEventsView);
			}
			return new WeatherEventsView((e.Kind == EventKind.Blizzard) ? 1 : 2, (int)phaseState.Phase, secondsLeft, (int)e.Biomes, !gameForced && e.Affects(localBiome), 0);
		}

		public static (WeatherEventsView View, string Token) ReadDetail(TempestEvent? e, double now, WeatherBiome localBiome, bool gameForced)
		{
			if (e == null)
			{
				return (View: default(WeatherEventsView), Token: "");
			}
			PhaseState phaseState = Timeline.At(e, now);
			if (phaseState.Phase == EventPhase.Idle)
			{
				return (View: default(WeatherEventsView), Token: "");
			}
			float secondsLeft = (float)Math.Max(0.0, Math.Min(3600.0, phaseState.SecondsLeft));
			return (View: new WeatherEventsView(WeatherEventsDetail.Number(e.Kind), (int)phaseState.Phase, secondsLeft, (int)e.Biomes, !gameForced && e.Affects(localBiome), 0), Token: EventKinds.Token(e.Kind));
		}

		public bool Equals(WeatherEventsView other)
		{
			if (Kind == other.Kind && Phase == other.Phase && SecondsLeft.Equals(other.SecondsLeft) && Biomes == other.Biomes && LocalAffected == other.LocalAffected)
			{
				return Revision == other.Revision;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((((Kind * 397) ^ Phase) * 397) ^ Biomes) * 397) ^ Revision ^ (LocalAffected ? 7919 : 0);
		}
	}
	public static class WeatherEventsDetail
	{
		public const string Id = "meadworks.weather.events.detail";

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

		public static int Number(EventKind kind)
		{
			return (int)(kind + 1);
		}
	}
	public sealed class RevisionCounter
	{
		private int revision;

		private int kind = -1;

		private int phase = -1;

		private int biomes = -1;

		public int Observe(WeatherEventsView view)
		{
			if (view.Kind != kind || view.Phase != phase || view.Biomes != biomes)
			{
				kind = view.Kind;
				phase = view.Phase;
				biomes = view.Biomes;
				revision++;
			}
			return revision;
		}
	}
}
namespace ExtraPotions.Tempest.Events
{
	public static class EventRecord
	{
		public const string Version = "t1";

		public const int MaximumLength = 256;

		public static string Encode(ScheduleState state)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			TempestEvent current = state.Current;
			string text = ((current == null || EventKinds.Extended(current.Kind)) ? "-" : Fields(current, (current.Kind == EventKind.Blizzard) ? "b" : "t"));
			return string.Join(";", "t1", I(state.NextSerial), state.LastRolledDay.ToString(CultureInfo.InvariantCulture), state.LastStartDay.ToString(CultureInfo.InvariantCulture), text).ToLowerInvariant();
		}

		public static bool TryDecode(string? text, out ScheduleState state)
		{
			state = ScheduleState.Empty;
			if (string.IsNullOrEmpty(text) || text.Length > 256)
			{
				return false;
			}
			foreach (char c in text)
			{
				if ((c < '0' || c > '9') && c != '.' && c != '+' && c != '-' && c != ';' && c != ',' && c != 'b' && c != 't' && c != 'e')
				{
					return false;
				}
			}
			string[] array = text.Split(';');
			if (array.Length != 5 || array[0] != "t1")
			{
				return false;
			}
			if (!int.TryParse(array[1], NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (!long.TryParse(array[2], NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result2))
			{
				return false;
			}
			if (!long.TryParse(array[3], NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result3))
			{
				return false;
			}
			TempestEvent e = null;
			if (array[4] != "-" && !TryEvent(array[4], out e))
			{
				return false;
			}
			try
			{
				state = new ScheduleState(e, result2, result3, result);
				return true;
			}
			catch (ArgumentException)
			{
				state = ScheduleState.Empty;
				return false;
			}
		}

		public static string? Canonical(string? text)
		{
			if (!TryDecode(text, out ScheduleState state))
			{
				return null;
			}
			return Encode(state);
		}

		private static bool TryEvent(string text, out TempestEvent? e)
		{
			return TryFields(text, (string letter) => (!(letter == "b")) ? ((!(letter == "t")) ? ((EventKind?)null) : new EventKind?(EventKind.Thunderstorm)) : new EventKind?(EventKind.Blizzard), out e);
		}

		internal static string Fields(TempestEvent e, string letter)
		{
			return string.Join(",", e.Serial.ToString(CultureInfo.InvariantCulture), letter, e.Start.ToString("R", CultureInfo.InvariantCulture), I(e.WarningSeconds), I(e.ActiveSeconds), I(e.ClearingSeconds), I(e.Seed), I((int)e.Biomes));
		}

		internal static bool TryFields(string text, Func<string, EventKind?> kindOf, out TempestEvent? e)
		{
			e = null;
			string[] array = text.Split(',');
			if (array.Length != 8)
			{
				return false;
			}
			EventKind? eventKind = kindOf(array[1]);
			if (!eventKind.HasValue)
			{
				return false;
			}
			if (!Int(array[0], out var value) || !Int(array[3], out var value2) || !Int(array[4], out var value3) || !Int(array[5], out var value4) || !Int(array[6], out var value5) || !Int(array[7], out var value6))
			{
				return false;
			}
			if (!double.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || double.IsNaN(result) || double.IsInfinity(result))
			{
				return false;
			}
			try
			{
				e = new TempestEvent(value, eventKind.Value, result, value2, value3, value4, value5, (WeatherBiome)value6);
				return true;
			}
			catch (ArgumentException)
			{
				return false;
			}
		}

		private static bool Int(string s, out int value)
		{
			return int.TryParse(s, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out value);
		}

		private static string I(int value)
		{
			return value.ToString(CultureInfo.InvariantCulture);
		}
	}
	public static class DryMark
	{
		public const string None = "0";

		public static string Encode(TempestEvent? e)
		{
			if (e == null || !e.Dry)
			{
				return "0";
			}
			return e.Serial.ToString(CultureInfo.InvariantCulture);
		}

		public static string? Canonical(string? text)
		{
			if (string.IsNullOrEmpty(text) || text.Length > 10)
			{
				return null;
			}
			int i;
			for (i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (c < '0' || c > '9')
				{
					return null;
				}
			}
			if (text.Length > 1 && text[0] == '0')
			{
				return null;
			}
			if (!int.TryParse(text, NumberStyles.None, CultureInfo.InvariantCulture, out i))
			{
				return null;
			}
			return text;
		}

		public static ScheduleState Apply(ScheduleState state, string? mark)
		{
			TempestEvent current = state.Current;
			if (current == null || current.Kind != EventKind.Thunderstorm || Canonical(mark) != current.Serial.ToString(CultureInfo.InvariantCulture))
			{
				return state;
			}
			if (current.Dry)
			{
				return state;
			}
			return state.With(new TempestEvent(current.Serial, current.Kind, current.Start, current.WarningSeconds, current.ActiveSeconds, current.ClearingSeconds, current.Seed, current.Biomes, dry: true));
		}
	}
	public static class ExtendedRecord
	{
		public const string None = "0";

		public const string Version = "x1";

		public static string Encode(TempestEvent? e)
		{
			if (e != null && EventKinds.Extended(e.Kind))
			{
				return "x1;" + EventRecord.Fields(e, Letter(e.Kind)).ToLowerInvariant();
			}
			return "0";
		}

		public static string? Canonical(string? text)
		{
			if (text == "0")
			{
				return "0";
			}
			if (!TryDecode(text, out TempestEvent e))
			{
				return null;
			}
			return Encode(e);
		}

		public static bool TryDecode(string? text, out TempestEvent? e)
		{
			e = null;
			if (string.IsNullOrEmpty(text) || text.Length > 256 || !text.StartsWith("x1;", StringComparison.Ordinal))
			{
				return false;
			}
			return EventRecord.TryFields(text.Substring("x1".Length + 1), Kind, out e);
		}

		public static ScheduleState Apply(ScheduleState state, string? text)
		{
			if (state.Current != null || !TryDecode(text, out TempestEvent e) || e.Serial != state.NextSerial - 1)
			{
				return state;
			}
			return state.With(e);
		}

		private static string Letter(EventKind kind)
		{
			return kind switch
			{
				EventKind.AshStorm => "a", 
				EventKind.DenseFog => "f", 
				_ => "m", 
			};
		}

		private static EventKind? Kind(string letter)
		{
			return letter switch
			{
				"m" => EventKind.MeteorShower, 
				"a" => EventKind.AshStorm, 
				"f" => EventKind.DenseFog, 
				_ => null, 
			};
		}
	}
	public static class RecordMigration
	{
		public readonly struct Choice
		{
			public string? Text { get; }

			public bool Migrate { get; }

			public Choice(string? text, bool migrate)
			{
				Text = text;
				Migrate = migrate;
			}
		}

		public static Choice Choose(string? current, string? legacy)
		{
			string text = EventRecord.Canonical(current);
			if (text != null)
			{
				return new Choice(text, migrate: false);
			}
			string text2 = EventRecord.Canonical(legacy);
			if (text2 == null)
			{
				return new Choice(null, migrate: false);
			}
			return new Choice(text2, migrate: true);
		}
	}
	public sealed class ScheduleRules
	{
		public bool Enabled { get; }

		public float BlizzardChance { get; }

		public float StormChance { get; }

		public int MinimumDaysBetween { get; }

		public int WarningSeconds { get; }

		public int ActiveMinSeconds { get; }

		public int ActiveMaxSeconds { get; }

		public int ClearingSeconds { get; }

		public WeatherBiome BlizzardBiomes { get; }

		public WeatherBiome StormBiomes { get; }

		public float DryStormChance { get; }

		public float FogChance { get; }

		public WeatherBiome FogBiomes { get; }

		public float AshStormChance { get; }

		public WeatherBiome AshStormBiomes { get; }

		public float MeteorShowerChance { get; }

		public WeatherBiome MeteorShowerBiomes { get; }

		public ScheduleRules(bool enabled, float blizzardChance, float stormChance, int minimumDaysBetween, int warningSeconds, int activeMinSeconds, int activeMaxSeconds, int clearingSeconds, WeatherBiome blizzardBiomes, WeatherBiome stormBiomes, float dryStormChance = 0f, float fogChance = 0f, WeatherBiome fogBiomes = WeatherBiome.None, float ashStormChance = 0f, WeatherBiome ashStormBiomes = WeatherBiome.None, float meteorShowerChance = 0f, WeatherBiome meteorShowerBiomes = WeatherBiome.None)
		{
			Enabled = enabled;
			BlizzardChance = Clamp01(blizzardChance);
			StormChance = Clamp01(stormChance);
			MinimumDaysBetween = Math.Max(0, minimumDaysBetween);
			WarningSeconds = Math.Max(0, Math.Min(3600, warningSeconds));
			ActiveMinSeconds = Math.Max(1, Math.Min(3600, activeMinSeconds));
			ActiveMaxSeconds = Math.Max(ActiveMinSeconds, Math.Min(3600, activeMaxSeconds));
			ClearingSeconds = Math.Max(0, Math.Min(3600, clearingSeconds));
			BlizzardBiomes = blizzardBiomes & BiomeSets.Allowed(EventKind.Blizzard);
			StormBiomes = stormBiomes & BiomeSets.Allowed(EventKind.Thunderstorm);
			DryStormChance = Clamp01(dryStormChance);
			FogChance = Clamp01(fogChance);
			FogBiomes = fogBiomes & BiomeSets.Allowed(EventKind.DenseFog);
			AshStormChance = Clamp01(ashStormChance);
			AshStormBiomes = ashStormBiomes & BiomeSets.Allowed(EventKind.AshStorm);
			MeteorShowerChance = Clamp01(meteorShowerChance);
			MeteorShowerBiomes = meteorShowerBiomes & BiomeSets.Allowed(EventKind.MeteorShower);
		}

		public float Chance(EventKind kind)
		{
			return kind switch
			{
				EventKind.Blizzard => BlizzardChance, 
				EventKind.Thunderstorm => StormChance, 
				EventKind.LightningStorm => StormChance * DryStormChance, 
				EventKind.DenseFog => FogChance, 
				EventKind.AshStorm => AshStormChance, 
				EventKind.MeteorShower => MeteorShowerChance, 
				_ => 0f, 
			};
		}

		public WeatherBiome Biomes(EventKind kind)
		{
			switch (kind)
			{
			case EventKind.Blizzard:
				return BlizzardBiomes;
			case EventKind.Thunderstorm:
			case EventKind.LightningStorm:
				return StormBiomes;
			case EventKind.DenseFog:
				return FogBiomes;
			case EventKind.AshStorm:
				return AshStormBiomes;
			case EventKind.MeteorShower:
				return MeteorShowerBiomes;
			default:
				return WeatherBiome.None;
			}
		}

		private static float Clamp01(float v)
		{
			if (!float.IsNaN(v))
			{
				return Math.Max(0f, Math.Min(1f, v));
			}
			return 0f;
		}
	}
	public sealed class ScheduleState : IEquatable<ScheduleState>
	{
		public const int MaximumSerial = 1000000000;

		public const long NoStart = -2305843009213693952L;

		public static ScheduleState Empty => new ScheduleState(null, -1L, -2305843009213693952L, 1);

		public TempestEvent? Current { get; }

		public long LastRolledDay { get; }

		public long LastStartDay { get; }

		public int NextSerial { get; }

		public ScheduleState(TempestEvent? current, long lastRolledDay, long lastStartDay, int nextSerial)
		{
			if (lastRolledDay < -1)
			{
				throw new ArgumentException("Expected -1 or a day.", "lastRolledDay");
			}
			if (nextSerial < 1 || nextSerial > 1000000000)
			{
				throw new ArgumentException("Serial out of range.", "nextSerial");
			}
			if (current != null && current.Serial >= nextSerial)
			{
				throw new ArgumentException("The next serial must follow the current event.", "nextSerial");
			}
			Current = current;
			LastRolledDay = lastRolledDay;
			LastStartDay = lastStartDay;
			NextSerial = nextSerial;
		}

		public ScheduleState With(TempestEvent? current)
		{
			return new ScheduleState(current, LastRolledDay, LastStartDay, NextSerial);
		}

		public bool Equals(ScheduleState? other)
		{
			if (other != null && object.Equals(Current, other.Current) && LastRolledDay == other.LastRolledDay && LastStartDay == other.LastStartDay)
			{
				return NextSerial == other.NextSerial;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((LastRolledDay.GetHashCode() * 397) ^ LastStartDay.GetHashCode()) * 397) ^ NextSerial;
		}
	}
	public enum SchedulerOutcome
	{
		None,
		Started,
		Finished,
		Stopped,
		Busy,
		Refused
	}
	public readonly struct SchedulerResult
	{
		public ScheduleState State { get; }

		public SchedulerOutcome Outcome { get; }

		public SchedulerResult(ScheduleState state, SchedulerOutcome outcome)
		{
			State = state;
			Outcome = outcome;
		}
	}
	public static class Scheduler
	{
		private const ulong RollSalt = 8387230210553246721uL;

		private const ulong LengthSalt = 8387230210553246724uL;

		private const ulong SeedSalt = 8387230210553246725uL;

		private const ulong DrySalt = 8387230210553246726uL;

		private const ulong PickSalt = 8387230210553246727uL;

		public static long DayOf(double now, double dayLength)
		{
			if (!(dayLength > 0.0) || !(now >= 0.0))
			{
				return 0L;
			}
			return (long)Math.Floor(now / dayLength);
		}

		public static double RollTime(long worldSeed, long day, double dayLength)
		{
			return (double)day * dayLength + (0.05 + 0.9 * SeededRandom.Unit((ulong)worldSeed, (ulong)day, 8387230210553246721uL)) * dayLength;
		}

		public static SchedulerResult Tick(ScheduleState state, ScheduleRules rules, long worldSeed, double now, double dayLength, WeatherBiome occupied, WeatherBiome raided = WeatherBiome.None)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			if (rules == null)
			{
				throw new ArgumentNullException("rules");
			}
			if (state.Current != null && !rules.Enabled)
			{
				return new SchedulerResult(state.With(null), SchedulerOutcome.Stopped);
			}
			if (state.Current != null && Timeline.Finished(state.Current, now))
			{
				return new SchedulerResult(state.With(null), SchedulerOutcome.Finished);
			}
			long num = DayOf(now, dayLength);
			if (num <= state.LastRolledDay || now < RollTime(worldSeed, num, dayLength))
			{
				return new SchedulerResult(state, SchedulerOutcome.None);
			}
			ScheduleState state2 = new ScheduleState(state.Current, num, state.LastStartDay, state.NextSerial);
			if (!rules.Enabled || state.Current != null || num - state.LastStartDay < rules.MinimumDaysBetween || state.NextSerial >= 1000000000)
			{
				return new SchedulerResult(state2, SchedulerOutcome.None);
			}
			EventKind? eventKind = Pick(rules, SeededRandom.Unit((ulong)worldSeed, (ulong)num, 8387230210553246727uL));
			if (!eventKind.HasValue || (rules.Biomes(eventKind.Value) & occupied) == 0)
			{
				return new SchedulerResult(state2, SchedulerOutcome.None);
			}
			if ((rules.Biomes(eventKind.Value) & raided) != WeatherBiome.None)
			{
				return new SchedulerResult(state, SchedulerOutcome.None);
			}
			int val = rules.ActiveMinSeconds + (int)Math.Floor(SeededRandom.Unit((ulong)worldSeed, (ulong)num, 8387230210553246724uL) * (double)(rules.ActiveMaxSeconds - rules.ActiveMinSeconds + 1));
			int seed = (int)SeededRandom.Next((ulong)worldSeed, (ulong)num, 8387230210553246725uL);
			SchedulerResult result = Start(state2, rules, eventKind.Value, now, rules.WarningSeconds, Math.Min(val, rules.ActiveMaxSeconds), seed, dayLength, null, nightRule: true);
			if (result.Outcome != SchedulerOutcome.Started)
			{
				return new SchedulerResult(state2, SchedulerOutcome.None);
			}
			return result;
		}

		public static EventKind? Pick(ScheduleRules rules, double roll)
		{
			if (rules == null)
			{
				throw new ArgumentNullException("rules");
			}
			double num = 0.0;
			foreach (EventKind item in EventKinds.Rolled)
			{
				if (Enabled(rules, item))
				{
					num += (double)rules.Chance(item);
				}
			}
			if (!(num > 0.0))
			{
				return null;
			}
			double num2 = ((num > 1.0) ? (1.0 / num) : 1.0);
			double num3 = 0.0;
			foreach (EventKind item2 in EventKinds.Rolled)
			{
				if (Enabled(rules, item2))
				{
					num3 += (double)rules.Chance(item2) * num2;
					if (roll < num3)
					{
						return item2;
					}
				}
			}
			return null;
		}

		private static bool Enabled(ScheduleRules rules, EventKind kind)
		{
			if (rules.Chance(kind) > 0f)
			{
				return rules.Biomes(kind) != WeatherBiome.None;
			}
			return false;
		}

		public static SchedulerResult Summon(ScheduleState state, ScheduleRules rules, EventKind kind, double now, bool skipWarning, int seed, double dayLength, bool? dry = null)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			if (rules == null)
			{
				throw new ArgumentNullException("rules");
			}
			if (state.Current != null && !Timeline.Finished(state.Current, now))
			{
				return new SchedulerResult(state, SchedulerOutcome.Busy);
			}
			if (rules.Biomes(kind) == WeatherBiome.None || state.NextSerial >= 1000000000)
			{
				return new SchedulerResult(state, SchedulerOutcome.Refused);
			}
			int val = rules.ActiveMinSeconds + (int)Math.Floor(SeededRandom.Unit((ulong)seed, (ulong)now, 8387230210553246724uL) * (double)(rules.ActiveMaxSeconds - rules.ActiveMinSeconds + 1));
			bool flag = kind == EventKind.Thunderstorm || kind == EventKind.LightningStorm;
			bool? dry2 = ((kind == EventKind.LightningStorm) ? new bool?(true) : (dry.HasValue ? new bool?(dry.Value && flag) : ((bool?)null)));
			return Start(state, rules, flag ? EventKind.Thunderstorm : kind, now, (!skipWarning) ? rules.WarningSeconds : 0, Math.Min(val, rules.ActiveMaxSeconds), seed, dayLength, dry2, !skipWarning);
		}

		public static EventKind SummonedKind(SchedulerResult result, EventKind requested)
		{
			if (result.Outcome != SchedulerOutcome.Started || result.State.Current == null)
			{
				return requested;
			}
			return result.State.Current.Kind;
		}

		public static SchedulerResult Stop(ScheduleState state, double now)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			TempestEvent current = state.Current;
			if (current == null || Timeline.Finished(current, now))
			{
				return new SchedulerResult(state.With(null), SchedulerOutcome.None);
			}
			double start = Math.Max(0.0, now);
			return new SchedulerResult(state.With(new TempestEvent(current.Serial, current.Kind, start, 0, 0, current.ClearingSeconds, current.Seed, current.Biomes)), SchedulerOutcome.Stopped);
		}

		public static bool RollDry(EventKind kind, int seed, int serial, float chance)
		{
			if (kind == EventKind.Thunderstorm && chance > 0f)
			{
				return SeededRandom.Unit((ulong)seed, (ulong)serial, 8387230210553246726uL) < (double)chance;
			}
			return false;
		}

		private static SchedulerResult Start(ScheduleState state, ScheduleRules rules, EventKind kind, double now, int warning, int active, int seed, double dayLength, bool? dry, bool nightRule)
		{
			if (nightRule && EventKinds.NightOnly(kind) && !NightWindow.Fit(Math.Max(0.0, now), dayLength, warning, active, rules.ActiveMinSeconds, out warning, out active))
			{
				return new SchedulerResult(state, SchedulerOutcome.Refused);
			}
			int nextSerial = state.NextSerial;
			bool dry2 = dry ?? RollDry(kind, seed, nextSerial, rules.DryStormChance);
			TempestEvent tempestEvent = new TempestEvent(nextSerial, kind, Math.Max(0.0, now), warning, active, rules.ClearingSeconds, seed, rules.Biomes(kind), dry2);
			return new SchedulerResult(new ScheduleState(tempestEvent, state.LastRolledDay, DayOf(now, dayLength), tempestEvent.Serial + 1), SchedulerOutcome.Started);
		}
	}
	public static class NightWindow
	{
		public const double Dusk = 0.85;

		public const double Dawn = 0.15;

		public static double Length(double dayLength)
		{
			return 0.30000000000000004 * dayLength;
		}

		public static bool IsNight(double now, double dayLength)
		{
			if (!(dayLength > 0.0) || now < 0.0)
			{
				return false;
			}
			double num = now / dayLength - Math.Floor(now / dayLength);
			if (!(num >= 0.85))
			{
				return num < 0.15;
			}
			return true;
		}

		public static (double Start, double End) Next(double time, double dayLength)
		{
			double num = Math.Floor(time / dayLength);
			double num2 = time / dayLength - num;
			if (num2 < 0.15)
			{
				return (Start: time, End: (num + 0.15) * dayLength);
			}
			if (num2 >= 0.85)
			{
				return (Start: time, End: (num + 1.0 + 0.15) * dayLength);
			}
			return (Start: (num + 0.85) * dayLength, End: (num + 1.0 + 0.15) * dayLength);
		}

		public static bool Fit(double now, double dayLength, int warning, int active, int activeMin, out int fitWarning, out int fitActive)
		{
			fitWarning = warning;
			fitActive = active;
			if (!(dayLength > 0.0) || double.IsInfinity(dayLength) || active < 1)
			{
				return false;
			}
			double d = Length(dayLength);
			int num = Math.Max(1, Math.Min(activeMin, (int)Math.Floor(d)));
			double num2 = now + (double)warning;
			(double, double) tuple = Next(num2, dayLength);
			if (tuple.Item1 > num2 || tuple.Item2 - num2 < (double)num)
			{
				double time;
				if (tuple.Item1 > num2)
				{
					(time, _) = tuple;
				}
				else
				{
					time = tuple.Item2;
				}
				tuple = Next(time, dayLength);
				fitWarning = (int)Math.Ceiling(tuple.Item1 - now);
				num2 = now + (double)fitWarning;
			}
			if (fitWarning > 3600)
			{
				return false;
			}
			fitActive = (int)Math.Max(1.0, Math.Min(active, Math.Floor(tuple.Item2 - num2)));
			return true;
		}
	}
	public static class SeededRandom
	{
		public static ulong Next(ulong a, ulong b, ulong c)
		{
			return Mix(Mix(Mix(a ^ 0x9E3779B97F4A7C15uL) ^ b) ^ c);
		}

		public static double Unit(ulong a, ulong b, ulong c)
		{
			return (double)(Next(a, b, c) >> 11) * 1.1102230246251565E-16;
		}

		private static ulong Mix(ulong z)
		{
			z += 11400714819323198485uL;
			z = (z ^ (z >> 30)) * 13787848793156543929uL;
			z = (z ^ (z >> 27)) * 10723151780598845931uL;
			return z ^ (z >> 31);
		}
	}
	public enum EventKind
	{
		Blizzard,
		Thunderstorm,
		LightningStorm,
		DenseFog,
		AshStorm,
		MeteorShower
	}
	public static class EventKinds
	{
		public static IReadOnlyList<EventKind> All { get; } = Array.AsReadOnly((EventKind[])Enum.GetValues(typeof(EventKind)));

		public static IReadOnlyList<EventKind> Rolled { get; } = Array.AsReadOnly(new EventKind[5]
		{
			EventKind.Blizzard,
			EventKind.Thunderstorm,
			EventKind.DenseFog,
			EventKind.AshStorm,
			EventKind.MeteorShower
		});

		public static string Token(EventKind kind)
		{
			return kind switch
			{
				EventKind.Blizzard => "blizzard", 
				EventKind.Thunderstorm => "thunderstorm", 
				EventKind.LightningStorm => "lightning_storm", 
				EventKind.DenseFog => "dense_fog", 
				EventKind.AshStorm => "ash_storm", 
				EventKind.MeteorShower => "meteor_shower", 
				_ => throw new ArgumentException("Unknown kind.", "kind"), 
			};
		}

		public static bool Strikes(EventKind kind)
		{
			if (kind != EventKind.Thunderstorm && kind != EventKind.LightningStorm)
			{
				return kind == EventKind.MeteorShower;
			}
			return true;
		}

		public static bool Lightning(EventKind kind)
		{
			if (kind != EventKind.Thunderstorm)
			{
				return kind == EventKind.LightningStorm;
			}
			return true;
		}

		public static bool NightOnly(EventKind kind)
		{
			return kind == EventKind.MeteorShower;
		}

		public static bool Extended(EventKind kind)
		{
			if (kind != EventKind.DenseFog && kind != EventKind.AshStorm)
			{
				return kind == EventKind.MeteorShower;
			}
			return true;
		}
	}
	public enum EventPhase
	{
		Idle,
		Warning,
		Active,
		Clearing
	}
	[Flags]
	public enum WeatherBiome
	{
		None = 0,
		Meadows = 1,
		Swamp = 2,
		Mountain = 4,
		BlackForest = 8,
		Plains = 0x10,
		AshLands = 0x20,
		DeepNorth = 0x40,
		Ocean = 0x100,
		Mistlands = 0x200
	}
	public static class BiomeSets
	{
		private static readonly WeatherBiome[] Order = new WeatherBiome[9]
		{
			WeatherBiome.Meadows,
			WeatherBiome.BlackForest,
			WeatherBiome.Swamp,
			WeatherBiome.Mountain,
			WeatherBiome.Plains,
			WeatherBiome.Ocean,
			WeatherBiome.Mistlands,
			WeatherBiome.AshLands,
			WeatherBiome.DeepNorth
		};

		private const WeatherBiome Lowlands = WeatherBiome.Meadows | WeatherBiome.Swamp | WeatherBiome.BlackForest | WeatherBiome.Plains;

		public static IEnumerable<WeatherBiome> All => Order;

		public static WeatherBiome Allowed(EventKind kind)
		{
			return kind switch
			{
				EventKind.Blizzard => WeatherBiome.Meadows | WeatherBiome.Swamp | WeatherBiome.BlackForest | WeatherBiome.Plains | WeatherBiome.DeepNorth, 
				EventKind.AshStorm => WeatherBiome.AshLands, 
				EventKind.MeteorShower => WeatherBiome.Plains | WeatherBiome.AshLands, 
				_ => WeatherBiome.Meadows | WeatherBiome.Swamp | WeatherBiome.BlackForest | WeatherBiome.Plains | WeatherBiome.Ocean, 
			};
		}

		public static WeatherBiome Default(EventKind kind)
		{
			if (kind != EventKind.Blizzard)
			{
				return Allowed(kind);
			}
			return WeatherBiome.Meadows | WeatherBiome.BlackForest | WeatherBiome.DeepNorth;
		}

		public static WeatherBiome Parse(EventKind kind, string? text)
		{
			WeatherBiome weatherBiome = WeatherBiome.None;
			string[] array = (text ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				WeatherBiome[] order = Order;
				for (int j = 0; j < order.Length; j++)
				{
					WeatherBiome weatherBiome2 = order[j];
					if (string.Equals(weatherBiome2.ToString(), text2, StringComparison.OrdinalIgnoreCase))
					{
						weatherBiome |= weatherBiome2;
					}
				}
			}
			return weatherBiome & Allowed(kind);
		}

		public static string Format(WeatherBiome biomes)
		{
			return string.Join(", ", from b in Order
				where (biomes & b) != 0
				select b.ToString());
		}

		public static string Normalize(EventKind kind, string? text)
		{
			return Format(Parse(kind, text));
		}

		public static IReadOnlyList<string> Dropped(EventKind kind, string? text)
		{
			List<string> list = new List<string>();
			WeatherBiome allowed = Allowed(kind);
			string[] array = (text ?? "").Split(',');
			foreach (string text2 in array)
			{
				string name = text2.Trim();
				if (name.Length != 0 && !Order.Any((WeatherBiome b) => (allowed & b) != WeatherBiome.None && string.Equals(b.ToString(), name, StringComparison.OrdinalIgnoreCase)))
				{
					list.Add(name);
				}
			}
			return list;
		}

		public static bool IsSingle(WeatherBiome biome)
		{
			if (biome != WeatherBiome.None)
			{
				return (biome & (biome - 1)) == 0;
			}
			return false;
		}
	}
	public sealed class TempestEvent : IEquatable<TempestEvent>
	{
		public const int MaximumPhaseSeconds = 3600;

		public int Serial { get; }

		public EventKind Kind { get; }

		public double Start { get; }

		public int WarningSeconds { get; }

		public int ActiveSeconds { get; }

		public int ClearingSeconds { get; }

		public int Seed { get; }

		public WeatherBiome Biomes { get; }

		public bool Dry => Kind == EventKind.LightningStorm;

		public double ActiveStart => Start + (double)WarningSeconds;

		public double ClearingStart => ActiveStart + (double)ActiveSeconds;

		public double End => ClearingStart + (double)ClearingSeconds;

		public TempestEvent(int serial, EventKind kind, double start, int warningSeconds, int activeSeconds, int clearingSeconds, int seed, WeatherBiome biomes, bool dry = false)
		{
			if (serial < 1)
			{
				throw new ArgumentException("Serial starts at 1.", "serial");
			}
			if (!Enum.IsDefined(typeof(EventKind), kind))
			{
				throw new ArgumentException("Unknown kind.", "kind");
			}
			if (double.IsNaN(start) || double.IsInfinity(start) || start < 0.0)
			{
				throw new ArgumentException("Expected a finite world time.", "start");
			}
			Check(warningSeconds, "warningSeconds");
			Check(activeSeconds, "activeSeconds");
			Check(clearingSeconds, "clearingSeconds");
			if (biomes == WeatherBiome.None || (biomes & ~BiomeSets.Allowed(kind)) != WeatherBiome.None)
			{
				throw new ArgumentException("Biomes must be a non-empty set this kind allows.", "biomes");
			}
			if (dry && kind != EventKind.Thunderstorm && kind != EventKind.LightningStorm)
			{
				throw new ArgumentException("Only a thunderstorm can be dry.", "dry");
			}
			Serial = serial;
			Kind = (dry ? EventKind.LightningStorm : kind);
			Start = start;
			WarningSeconds = warningSeconds;
			ActiveSeconds = activeSeconds;
			ClearingSeconds = clearingSeconds;
			Seed = seed;
			Biomes = biomes;
		}

		public bool Affects(WeatherBiome biome)
		{
			if (biome != WeatherBiome.None)
			{
				return (Biomes & biome) == biome;
			}
			return false;
		}

		public bool Equals(TempestEvent? other)
		{
			if (other != null && Serial == other.Serial && Kind == other.Kind && Start.Equals(other.Start) && WarningSeconds == other.WarningSeconds && ActiveSeconds == other.ActiveSeconds && ClearingSeconds == other.ClearingSeconds && Seed == other.Seed)
			{
				return Biomes == other.Biomes;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (int)(((((uint)(Serial * 397) ^ (uint)Kind) * 397) ^ (uint)Start.GetHashCode()) * 397) ^ Seed;
		}

		public override string ToString()
		{
			return Kind.ToString() + " #" + Serial + " at " + Start.ToString("0.#", CultureInfo.InvariantCulture) + " (" + WarningSeconds + "/" + ActiveSeconds + "/" + ClearingSeconds + " s, " + BiomeSets.Format(Biomes) + ")";
		}

		private static void Check(int seconds, string name)
		{
			if (seconds < 0 || seconds > 3600)
			{
				throw new ArgumentException("Phase length out of range.", name);
			}
		}
	}
	public readonly struct PhaseState
	{
		public static PhaseState Idle => new PhaseState(EventPhase.Idle, 0.0, 0.0, 0.0);

		public EventPhase Phase { get; }

		public double SecondsLeft { get; }

		public double Progress { get; }

		public double SecondsUntilActive { get; }

		public PhaseState(EventPhase phase, double secondsLeft, double progress, double secondsUntilActive)
		{
			Phase = phase;
			SecondsLeft = secondsLeft;
			Progress = progress;
			SecondsUntilActive = secondsUntilActive;
		}
	}
	public static class Timeline
	{
		public static PhaseState At(TempestEvent e, double now)
		{
			if (e == null)
			{
				throw new ArgumentNullException("e");
			}
			if (double.IsNaN(now) || now < e.Start || now >= e.End)
			{
				return PhaseState.Idle;
			}
			if (now < e.ActiveStart)
			{
				return Make(EventPhase.Warning, now, e.Start, e.WarningSeconds, e.ActiveStart - now);
			}
			if (now < e.ClearingStart)
			{
				return Make(EventPhase.Active, now, e.ActiveStart, e.ActiveSeconds, 0.0);
			}
			return Make(EventPhase.Clearing, now, e.ClearingStart, e.ClearingSeconds, 0.0);
		}

		public static bool Finished(TempestEvent e, double now)
		{
			if (e != null)
			{
				return now >= e.End;
			}
			return false;
		}

		private static PhaseState Make(EventPhase phase, double now, double from, int length, double untilActive)
		{
			double num = now - from;
			return new PhaseState(phase, (double)length - num, (length <= 0) ? 0.0 : (num / (double)length), untilActive);
		}
	}
	public readonly struct VanillaEventArea
	{
		public float X { get; }

		public float Z { get; }

		public float Range { get; }

		public VanillaEventArea(float x, float z, float range)
		{
			X = x;
			Z = z;
			Range = range;
		}
	}
	public static class VanillaEvents
	{
		public const float CeilingY = 3000f;

		public static bool Inside(VanillaEventArea? area, float x, float y, float z)
		{
			if (!area.HasValue || y > 3000f)
			{
				return false;
			}
			VanillaEventArea value = area.Value;
			float num = x - value.X;
			float num2 = z - value.Z;
			return Math.Sqrt(num * num + num2 * num2) < (double)value.Range;
		}

		public static bool Covers(bool activeForPlayer, VanillaEventArea? area, float x, float y, float z)
		{
			if (!activeForPlayer)
			{
				return Inside(area, x, y, z);
			}
			return true;
		}
	}
}
namespace ExtraPotions.Tempest.Conversion
{
	public readonly struct ImportValue
	{
		public string SettingId { get; }

		public object Value { get; }

		public string Source { get; }

		public ImportValue(string settingId, object value, string source)
		{
			SettingId = settingId;
			Value = value;
			Source = source;
		}
	}
	public sealed class ImportPlan
	{
		public IReadOnlyList<ImportValue> Values { get; }

		public IReadOnlyList<string> OtherDisabled { get; }

		public IReadOnlyList<string> Notes { get; }

		internal ImportPlan(IReadOnlyList<ImportValue> values, IReadOnlyList<string> otherDisabled, IReadOnlyList<string> notes)
		{
			Values = values;
			OtherDisabled = otherDisabled;
			Notes = notes;
		}

		public string Report()
		{
			IEnumerable<string> first = new string[1] { "Source: NoFogBruh" }.Concat(Values.Select((ImportValue v) => "Set " + v.SettingId + " = " + (((bool)v.Value) ? "true" : "false") + " (from " + v.Source + ")"));
			IEnumerable<string> second;
			if (OtherDisabled.Count != 0)
			{
				IEnumerable<string> enumerable = new string[1] { "Set " + TempestSettings.Filter.OtherDisabled.Id + " = " + string.Join(", ", OtherDisabled) + " (merged with the current list)" };
				second = enumerable;
			}
			else
			{
				second = Enumerable.Empty<string>();
			}
			return string.Join("\n", first.Concat(second).Concat(Notes.Select((string n) => "Note: " + n)));
		}
	}
	public readonly struct SourceEntry
	{
		public string Section { get; }

		public string Key { get; }

		public string Value { get; }

		public SourceEntry(string section, string key, string value)
		{
			Section = section;
			Key = key;
			Value = value;
		}
	}
	public static class SourceConfig
	{
		public static IReadOnlyList<SourceEntry> Parse(string? text)
		{
			List<SourceEntry> list = new List<SourceEntry>();
			string section = "";
			string[] array = (text ?? "").Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				if (text2[0] == '[' && text2[text2.Length - 1] == ']')
				{
					section = text2.Substring(1, text2.Length - 2).Trim();
					continue;
				}
				int num = text2.IndexOf('=');
				if (num > 0)
				{
					string text3 = text2.Substring(0, num).Trim();
					if (text3.Length != 0)
					{
						list.Add(new SourceEntry(section, text3, text2.Substring(num + 1).Trim()));
					}
				}
			}
			return list;
		}
	}
	public static class SourceImport
	{
		public const string NoFogBruhFile = "vapok.mods.nofogbruh.cfg";

		private const string SectionPrefix = "Weather Events - ";

		public static ImportPlan Plan(string? text)
		{
			List<ImportValue> list = new List<ImportValue>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			Dictionary<string, WeatherSwitch> dictionary = WeatherSwitches.All.ToDictionary<WeatherSwitch, string>((WeatherSwitch s) => s.SourceSection + "\n" + s.Key, StringComparer.Ordinal);
			foreach (SourceEntry item in SourceConfig.Parse(text))
			{
				if (!item.Section.StartsWith("Weather Events - ", StringComparison.Ordinal))
				{
					continue;
				}
				string text2 = "[" + item.Section + "] " + item.Key;
				if (!bool.TryParse(item.Value, out var result))
				{
					list3.Add(text2 + " = " + item.Value + ": not true or false, skipped");
					continue;
				}
				if (dictionary.TryGetValue(item.Section + "\n" + item.Key, out var value))
				{
					list.Add(new ImportValue(TempestSettings.Filter.Switches[value].Id, result, text2));
					continue;
				}
				string text3 = DynamicEnvironment(item.Key);
				if (text3 == null)
				{
					list3.Add(text2 + ": unknown key, skipped");
				}
				else if (result)
				{
					list3.Add(text2 + ": other environment " + text3 + " stays allowed (nothing to import)");
				}
				else
				{
					list2.Add(text3);
				}
			}
			return new ImportPlan(list, list2.Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList(), list3);
		}

		public static string MergeOther(string? current, IEnumerable<string> imported)
		{
			return WeatherFilter.NormalizeList(string.Join(",", new string[1] { current ?? "" }.Concat(imported ?? Enumerable.Empty<string>())));
		}

		private static string? DynamicEnvironment(string key)
		{
			if (!key.StartsWith("Enable ", StringComparison.Ordinal) || !key.EndsWith(" Weather", StringComparison.Ordinal) || key.Length <= "Enable ".Length + " Weather".Length)
			{
				return null;
			}
			string text = key.Substring("Enable ".Length, key.Length - "Enable ".Length - " Weather".Length).Trim();
			if (text.Length != 0 && text.IndexOf(' ') < 0)
			{
				return text;
			}
			return null;
		}
	}
}
namespace ExtraPotions.Tempest.Config
{
	public static class DefaultUpgrades
	{
		public const string BlizzardBiomesBeforeDeepNorth = "Meadows, BlackForest";

		private static readonly Dictionary<TempestSetting<string>, string> earlier = new Dictionary<TempestSetting<string>, string> { [TempestSettings.Schedule.BlizzardBiomes] = "Meadows, BlackForest" };

		public static string? Upgrade(TempestSetting setting, string? saved)
		{
			if (!(setting is TempestSetting<string> tempestSetting) || saved == null || !earlier.TryGetValue(tempestSetting, out string value) || !string.Equals(saved, value, StringComparison.Ordinal))
			{
				return null;
			}
			return tempestSetting.Default;
		}

		public static bool MissesDeepNorth(TempestSetting setting, string? saved)
		{
			if (setting != TempestSettings.Schedule.BlizzardBiomes || saved == null)
			{
				return false;
			}
			WeatherBiome weatherBiome = BiomeSets.Parse(EventKind.Blizzard, saved);
			if (weatherBiome != WeatherBiome.None)
			{
				return (weatherBiome & WeatherBiome.DeepNorth) == 0;
			}
			return false;
		}
	}
	public enum SessionKind
	{
		SinglePlayer,
		Host,
		DedicatedServer,
		RemoteClient
	}
	public enum ServerKind
	{
		Unknown,
		Vanilla,
		CrucibleWithoutTempest,
		Tempest
	}
	public enum BlockReason
	{
		None,
		SetByServer,
		VanillaServer,
		ProductDisabled,
		NotAdmin,
		AuthorityPending
	}
	public readonly struct SessionFacts
	{
		public static SessionFacts SinglePlayer { get; } = new SessionFacts(SessionKind.SinglePlayer, ServerKind.Tempest, admin: true);

		public SessionKind Kind { get; }

		public ServerKind Server { get; }

		public bool Admin { get; }

		public bool IsAuthority => Kind != SessionKind.RemoteClient;

		public SessionFacts(SessionKind kind, ServerKind server, bool admin)
		{
			Kind = kind;
			Server = server;
			Admin = admin;
		}
	}
	public static class SettingAccess
	{
		public static BlockReason Decide(SettingScope scope, SessionFacts facts)
		{
			if (facts.IsAuthority || scope == SettingScope.Local)
			{
				return BlockReason.None;
			}
			switch (facts.Server)
			{
			case ServerKind.Unknown:
				return BlockReason.AuthorityPending;
			case ServerKind.Vanilla:
				return BlockReason.VanillaServer;
			case ServerKind.CrucibleWithoutTempest:
				return BlockReason.ProductDisabled;
			default:
				if (facts.Admin)
				{
					return BlockReason.None;
				}
				if (scope != SettingScope.Cheat)
				{
					return BlockReason.SetByServer;
				}
				return BlockReason.NotAdmin;
			}
		}

		public static bool CheatLocked(SessionFacts facts)
		{
			if (!facts.IsAuthority)
			{
				return facts.Server != ServerKind.Tempest;
			}
			return false;
		}
	}
	public enum SettingScope
	{
		Local,
		ServerAuthoritative,
		Cheat
	}
	public abstract class TempestSetting
	{
		private static readonly IReadOnlyList<string> NoChoices = Array.Empty<string>();

		public string Section { get; }

		public string Key { get; }

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

		public SettingScope Scope { get; }

		public string Description { get; }

		public IReadOnlyList<string> Choices { get; }

		public bool Hidden { get; }

		public abstract Type ValueType { get; }

		public abstract object DefaultValue { get; }

		public abstract object? SafeValue { get; }

		public abstract object? Minimum { get; }

		public abstract object? Maximum { get; }

		private protected TempestSetting(string section, string key, SettingScope scope, string description, IReadOnlyList<string>? choices, bool hidden)
		{
			if (string.IsNullOrWhiteSpace(section) || section.Trim() != section)
			{
				throw new ArgumentException("Expected a trimmed section name.", "section");
			}
			if (string.IsNullOrWhiteSpace(key) || key.Trim() != key)
			{
				throw new ArgumentException("Expected a trimmed key.", "key");
			}
			if (!Enum.IsDefined(typeof(SettingScope), scope))
			{
				throw new ArgumentException("Unknown scope.", "scope");
			}
			if (string.IsNullOrWhiteSpace(description))
			{
				throw new ArgumentException("Expected a description.", "description");
			}
			if (hidden && scope == SettingScope.Cheat)
			{
				throw new ArgumentException(section + "." + key + ": a cheat cannot be hidden; cheats stay visible for review.", "hidden");
			}
			Section = section;
			Key = key;
			Scope = scope;
			Description = description;
			Choices = choices ?? NoChoices;
			Hidden = hidden;
		}

		public abstract object NormalizeBoxed(object? value);

		public override string ToString()
		{
			return Id + " (" + Scope.ToString() + (Hidden ? ", hidden" : "") + ")";
		}

		public static TempestSetting<bool> Toggle(string section, string key, bool defaultValue, SettingScope scope, string description, bool? safe = null, bool hidden = false)
		{
			return new TempestSetting<bool>(section, key, scope, description, defaultValue, safe, null, (bool v) => v, null, hidden);
		}

		public static TempestSetting<int> Integer(string section, string key, int defaultValue, int min, int max, SettingScope scope, string description)
		{
			if (min > max)
			{
				throw new ArgumentException("Minimum above maximum.", "min");
			}
			return new TempestSetting<int>(section, key, scope, description, defaultValue, null, (min, max), (int v) => Math.Min(max, Math.Max(min, v)));
		}

		public static TempestSetting<float> Number(string section, string key, float defaultValue, float min, float max, SettingScope scope, string description)
		{
			if (!(min <= max) || float.IsInfinity(min) || float.IsInfinity(max))
			{
				throw new ArgumentException("Expected a finite range.", "min");
			}
			return new TempestSetting<float>(section, key, scope, description, defaultValue, null, (min, max), (float v) => (!float.IsNaN(v) && !float.IsInfinity(v)) ? Math.Min(max, Math.Max(min, v)) : defaultValue);
		}

		public static TempestSetting<TEnum> Choice<TEnum>(string section, string key, TEnum defaultValue, SettingScope scope, string description) where TEnum : struct, Enum
		{
			return new TempestSetting<TEnum>(section, key, scope, description, defaultValue, null, null, (TEnum v) => (!Enum.IsDefined(typeof(TEnum), v)) ? defaultValue : v, Enum.GetNames(typeof(TEnum)));
		}

		public static TempestSetting<string> Text(string section, string key, string defaultValue, SettingScope scope, string description, Func<string, string> normalize, bool hidden = false)
		{
			if (normalize == null)
			{
				throw new ArgumentNullException("normalize");
			}
			return new TempestSetting<string>(section, key, scope, description, defaultValue, null, null, normalize, null, hidden);
		}
	}
	public sealed class TempestSetting<T> : TempestSetting
	{
		private readonly Func<T, T> normalize;

		private readonly bool hasSafe;

		private readonly (T Min, T Max)? range;

		public T Default { get; }

		public T Safe { get; }

		public override Type ValueType => typeof(T);

		public override object DefaultValue => Default;

		public override object? SafeValue
		{
			get
			{
				if (!hasSafe)
				{
					return null;
				}
				return Safe;
			}
		}

		public override object? Minimum
		{
			get
			{
				if (!range.HasValue)
				{
					return null;
				}
				return range.Value.Min;
			}
		}

		public override object? Maximum
		{
			get
			{
				if (!range.HasValue)
				{
					return null;
				}
				return range.Value.Max;
			}
		}

		internal TempestSetting(string section, string key, SettingScope scope, string description, T defaultValue, object? safe, (T, T)? range, Func<T, T> nor