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.Cairn.Config;
using ExtraPotions.Cairn.Conversion;
using ExtraPotions.Cairn.Hud;
using ExtraPotions.Cairn.Integration;
using ExtraPotions.Cairn.Localization;
using ExtraPotions.Cairn.Radius;
using ExtraPotions.Cairn.Visibility;
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.18.0")]
[assembly: AssemblyInformationalVersion("0.1.18+fatal: not a git repository (or any of the parent directories): .git")]
[assembly: AssemblyProduct("Cairn.Core")]
[assembly: AssemblyTitle("Cairn.Core")]
[assembly: AssemblyVersion("0.1.18.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.Cairn
{
	public static class CairnCore
	{
		public const string PluginGuid = "com.meadworks.cairn";

		public const string ProductName = "Cairn";

		public const string ProductVersion = "0.1.18";

		public const string Family = "Waystone";

		public const string TokenNamespace = "cairn";

		public const string TokenPrefix = "meadworks_cairn_";

		public const string DataPrefix = "Cairn.";

		public const string SupportedGameVersion = "1.0.17";
	}
}
namespace ExtraPotions.Cairn.Visibility
{
	public enum VisibilityEffect
	{
		DistanceFog,
		GroundMist,
		FogClouds,
		MistEmitters,
		OceanMist,
		MistlandsMist,
		ParticleMist,
		CaveMist,
		SnowstormFog,
		SnowGlint,
		AshlandsMist,
		AshlandsFader,
		DeepNorthMist,
		DeepNorthFader,
		AmbientOcclusion,
		Smoke
	}
	public sealed class VisibilityEffectInfo
	{
		public VisibilityEffect Effect { get; }

		public string Name { get; }

		public string Description { get; }

		internal VisibilityEffectInfo(VisibilityEffect effect, string name, string description)
		{
			Effect = effect;
			Name = name;
			Description = description;
		}

		public override string ToString()
		{
			return Name;
		}
	}
	public static class VisibilityEffects
	{
		public static IReadOnlyList<VisibilityEffectInfo> All { get; } = Array.AsReadOnly(new VisibilityEffectInfo[16]
		{
			E(VisibilityEffect.DistanceFog, "Distance Fog", "the distance fog in every biome and weather"),
			E(VisibilityEffect.GroundMist, "Ground Mist", "the ground mist near the player"),
			E(VisibilityEffect.FogClouds, "Fog Clouds", "the low fog clouds"),
			E(VisibilityEffect.MistEmitters, "Mist Emitters", "the weather mist emitters"),
			E(VisibilityEffect.OceanMist, "Ocean Mist", "the mist over the ocean"),
			E(VisibilityEffect.MistlandsMist, "Mistlands Mist", "the Mistlands mist"),
			E(VisibilityEffect.ParticleMist, "Particle Mist", "the volumetric particle mist in mist areas"),
			E(VisibilityEffect.CaveMist, "Cave Mist", "the mist inside troll caves and mountain caves"),
			E(VisibilityEffect.SnowstormFog, "Snowstorm Fog", "the snowstorm and blizzard fog"),
			E(VisibilityEffect.SnowGlint, "Snow Glint", "the blinding glint on snowfields"),
			E(VisibilityEffect.AshlandsMist, "Ashlands Mist", "the smoky Ashlands mist"),
			E(VisibilityEffect.AshlandsFader, "Ashlands Fader", "the Ashlands fader haze"),
			E(VisibilityEffect.DeepNorthMist, "Deep North Mist", "the Deep North mist"),
			E(VisibilityEffect.DeepNorthFader, "Deep North Fader", "the Deep North fader haze"),
			E(VisibilityEffect.AmbientOcclusion, "Ambient Occlusion", "the ambient occlusion haze"),
			E(VisibilityEffect.Smoke, "Smoke", "the smoke of fires")
		});

		private static VisibilityEffectInfo E(VisibilityEffect effect, string name, string description)
		{
			return new VisibilityEffectInfo(effect, name, description);
		}

		public static VisibilityEffectInfo Of(VisibilityEffect effect)
		{
			return All[(int)effect];
		}
	}
	public enum TargetAction
	{
		None,
		Deactivate,
		Restore
	}
	public static class VisibilityPolicy
	{
		public static bool IsGateLike(VisibilityEffect effect)
		{
			if (effect != VisibilityEffect.MistlandsMist && effect != VisibilityEffect.ParticleMist)
			{
				return effect == VisibilityEffect.CaveMist;
			}
			return true;
		}

		public static bool Removes(VisibilityEffect effect, bool remove, bool serverAllows, bool held)
		{
			if (remove && serverAllows)
			{
				if (held)
				{
					return !IsGateLike(effect);
				}
				return true;
			}
			return false;
		}

		public static BlockReason Reason(VisibilityEffect effect, bool remove, bool serverAllows, SessionFacts facts)
		{
			if (!remove)
			{
				return BlockReason.None;
			}
			if (IsGateLike(effect) && GatePolicy.Holds(facts))
			{
				return GatePolicy.HeldReason(facts);
			}
			if (!serverAllows)
			{
				return BlockReason.SetByServer;
			}
			return BlockReason.None;
		}

		public static TargetAction SceneAction(bool removes, bool active, bool ownedByCairn)
		{
			if (removes)
			{
				if (!active)
				{
					return TargetAction.None;
				}
				return TargetAction.Deactivate;
			}
			if (!(!active && ownedByCairn))
			{
				return TargetAction.None;
			}
			return TargetAction.Restore;
		}

		public static float SmokeAlpha(float alpha, bool removes, float strength = 1f)
		{
			if (!removes)
			{
				return alpha * strength;
			}
			return 0f;
		}

		public static float Strength(float strength, bool serverAllows, bool held, bool gateLike)
		{
			if (!serverAllows || (held && gateLike) || float.IsNaN(strength))
			{
				return 1f;
			}
			if (!(strength < 0f))
			{
				if (!(strength > 1f))
				{
					return strength;
				}
				return 1f;
			}
			return 0f;
		}
	}
	public enum TargetKind
	{
		EnvironmentChild,
		LocationChild,
		FogDensity,
		PostProcessingFog,
		PostProcessingAmbientOcclusion,
		MistEmitter,
		DistantFogEmitter,
		ParticleMist,
		SnowGlintShader,
		SmokeAlpha
	}
	public enum TargetSource
	{
		NoFogBruh,
		BetterFog
	}
	public sealed class VisibilityTarget
	{
		public VisibilityEffect Effect { get; }

		public TargetKind Kind { get; }

		public TargetSource Source { get; }

		public string? Path { get; }

		public string? LocationListPrefix { get; }

		internal VisibilityTarget(VisibilityEffect effect, TargetKind kind, TargetSource source, string? path = null, string? locationListPrefix = null)
		{
			Effect = effect;
			Kind = kind;
			Source = source;
			Path = path;
			LocationListPrefix = locationListPrefix;
		}

		public override string ToString()
		{
			return Effect.ToString() + ": " + Kind.ToString() + ((Path == null) ? "" : (" " + ((LocationListPrefix == null) ? "" : (LocationListPrefix + ":")) + Path));
		}
	}
	public static class VisibilityTargets
	{
		public const string EnvironmentRoot = "_GameMain/_Environment";

		public const string SnowGlintProperty = "_SnowGlintStrength";

		private static readonly IReadOnlyList<VisibilityTarget>[] ByEffect = Enum.GetValues(typeof(VisibilityEffect)).Cast<VisibilityEffect>().Select((Func<VisibilityEffect, IReadOnlyList<VisibilityTarget>>)((VisibilityEffect e) => All.Where((VisibilityTarget t) => t.Effect == e).ToList().AsReadOnly()))
			.ToArray();

		public static IReadOnlyList<VisibilityTarget> All { get; } = Array.AsReadOnly(new VisibilityTarget[23]
		{
			Hook(VisibilityEffect.DistanceFog, TargetKind.FogDensity),
			Env(VisibilityEffect.DistanceFog, "FollowPlayer/Mist"),
			Hook(VisibilityEffect.DistanceFog, TargetKind.PostProcessingFog),
			Env(VisibilityEffect.DistanceFog, "Distant_fog_planes"),
			Hook(VisibilityEffect.DistanceFog, TargetKind.DistantFogEmitter),
			Env(VisibilityEffect.GroundMist, "FollowPlayer/GroundMist"),
			Env(VisibilityEffect.FogClouds, "FollowPlayer/FogClouds"),
			Hook(VisibilityEffect.MistEmitters, TargetKind.MistEmitter),
			Env(VisibilityEffect.OceanMist, "OceanMist"),
			Loc(VisibilityEffect.MistlandsMist, "_LocationList_Mistlands", "environment_effects/FollowPlayer/Mistlands_Globalmist"),
			Hook(VisibilityEffect.ParticleMist, TargetKind.ParticleMist),
			Env(VisibilityEffect.CaveMist, "FollowPlayer/InteriorDust"),
			Loc(VisibilityEffect.CaveMist, "_LocationList_MountainCaves", "environment/followplayer/env_mountain_cave/mist"),
			Loc(VisibilityEffect.CaveMist, "_LocationList_MountainCaves", "environment/followplayer/env_mountain_cave_hildir/mist"),
			Env(VisibilityEffect.SnowstormFog, "FollowPlayer/SnowStorm"),
			Env(VisibilityEffect.SnowstormFog, "FollowPlayer/Blizzard"),
			Hook(VisibilityEffect.SnowGlint, TargetKind.SnowGlintShader),
			Loc(VisibilityEffect.AshlandsMist, "_LocationList_Ashlands", "environment_effects/FollowPlayer/Ashlands_Misty"),
			Loc(VisibilityEffect.AshlandsFader, "_LocationList_Ashlands", "environment_effects/FollowPlayer/Ashlands_FaderFX"),
			Loc(VisibilityEffect.DeepNorthMist, "_LocationList_DeepNorth", "environment_effects/FollowPlayer/DeepNorth_Misty"),
			Loc(VisibilityEffect.DeepNorthFader, "_LocationList_DeepNorth", "environment_effects/FollowPlayer/DeepNorth_FaderFX"),
			Hook(VisibilityEffect.AmbientOcclusion, TargetKind.PostProcessingAmbientOcclusion),
			Hook(VisibilityEffect.Smoke, TargetKind.SmokeAlpha, TargetSource.BetterFog)
		});

		private static VisibilityTarget Env(VisibilityEffect e, string path)
		{
			return new VisibilityTarget(e, TargetKind.EnvironmentChild, TargetSource.NoFogBruh, path);
		}

		private static VisibilityTarget Loc(VisibilityEffect e, string prefix, string path)
		{
			return new VisibilityTarget(e, TargetKind.LocationChild, TargetSource.NoFogBruh, path, prefix);
		}

		private static VisibilityTarget Hook(VisibilityEffect e, TargetKind kind, TargetSource source = TargetSource.NoFogBruh)
		{
			return new VisibilityTarget(e, kind, source);
		}

		public static IReadOnlyList<VisibilityTarget> Of(VisibilityEffect effect)
		{
			return ByEffect[(int)effect];
		}
	}
}
namespace ExtraPotions.Cairn.WorldTime
{
	public static class WorldClockRate
	{
		public static float ScaleDelta(float delta, float rate)
		{
			if (!(delta > 0f) || float.IsInfinity(delta) || float.IsNaN(rate) || float.IsInfinity(rate))
			{
				return delta;
			}
			rate = Math.Min(10f, Math.Max(0.1f, rate));
			double num = (double)delta * (double)rate;
			if (!(num <= 3.4028234663852886E+38))
			{
				return delta;
			}
			return (float)num;
		}
	}
}
namespace ExtraPotions.Cairn.Skill
{
	public static class SkillHash
	{
		public static int Of(string text)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			int num = 5381;
			int num2 = num;
			for (int i = 0; i < text.Length && text[i] != 0; i += 2)
			{
				num = ((num << 5) + num) ^ text[i];
				if (i == text.Length - 1 || text[i + 1] == '\0')
				{
					break;
				}
				num2 = ((num2 << 5) + num2) ^ text[i + 1];
			}
			return num + num2 * 1566083941;
		}

		public static int CustomType(string identity)
		{
			return Of(identity) & 0x7FFFFFFF;
		}
	}
	public enum ExploreSource
	{
		Other,
		Natural,
		Vantage
	}
	public sealed class ExploreScope
	{
		public ExploreSource Current { get; private set; }

		public ExploreSource Enter(ExploreSource source)
		{
			ExploreSource current = Current;
			Current = source;
			return current;
		}

		public void Exit(ExploreSource previous)
		{
			Current = previous;
		}
	}
	public static class ExploreCells
	{
		public static int CountNew(int px, int py, float radius, float pixelSize, int textureSize, Func<int, bool> explored)
		{
			if (explored == null)
			{
				throw new ArgumentNullException("explored");
			}
			if (textureSize <= 0 || !(pixelSize > 0f) || float.IsInfinity(pixelSize) || float.IsNaN(radius) || float.IsInfinity(radius))
			{
				return 0;
			}
			int num = (int)Math.Ceiling(Math.Max(0f, radius) / pixelSize);
			long num2 = (long)num * (long)num;
			int num3 = 0;
			for (int i = Math.Max(0, py - num); i <= Math.Min(textureSize - 1, py + num); i++)
			{
				for (int j = Math.Max(0, px - num); j <= Math.Min(textureSize - 1, px + num); j++)
				{
					long num4 = j - px;
					long num5 = i - py;
					if (num4 * num4 + num5 * num5 <= num2 && !explored(i * textureSize + j))
					{
						num3++;
					}
				}
			}
			return num3;
		}
	}
	public sealed class DiscoveryRequests
	{
		public const float WindowSeconds = 30f;

		private readonly List<(string Name, int Type, float At)> pending = new List<(string, int, float)>();

		public void Record(string? pinName, int pinType, float now)
		{
			if (pinName != null)
			{
				Prune(now);
				pending.Add((pinName, pinType, now));
			}
		}

		public bool Natural(string? pinName, int pinType, float now)
		{
			if (pinName == null)
			{
				return false;
			}
			Prune(now);
			foreach (var item in pending)
			{
				if (item.Type == pinType && string.Equals(item.Name, pinName, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		public void Clear()
		{
			pending.Clear();
		}

		private void Prune(float now)
		{
			pending.RemoveAll(((string Name, int Type, float At) r) => float.IsNaN(now) || now - r.At > 30f || now < r.At - 30f);
		}
	}
	public static class ExplorationExperience
	{
		public static float Area(ExploreSource source, int newTexels, float texelMetres, SkillValues values)
		{
			if (source != ExploreSource.Other)
			{
				return ExplorationSkill.AreaExperience(newTexels, texelMetres, values);
			}
			return 0f;
		}

		public static float Discovery(bool pinAdded, bool natural, SkillValues values)
		{
			if (!(pinAdded && natural))
			{
				return 0f;
			}
			return ExplorationSkill.DiscoveryExperience(values);
		}

		public static float Biome(bool knownBefore, SkillValues values)
		{
			if (!knownBefore)
			{
				return ExplorationSkill.BiomeExperience(values);
			}
			return 0f;
		}
	}
	public readonly struct SkillValues
	{
		public static SkillValues Defaults => new SkillValues(CairnSettings.Skill.Enabled.Default, CairnSettings.Skill.ExperiencePerSquareKilometre.Default, CairnSettings.Skill.LocationDiscoveryExperience.Default, CairnSettings.Skill.NewBiomeExperience.Default, CairnSettings.Skill.LandRadiusAt100.Default, CairnSettings.Skill.WeatherPenaltyReductionAt100.Default, CairnSettings.Skill.NightPenaltyReductionAt100.Default, CairnSettings.Skill.VantageLevel.Default, CairnSettings.Skill.VantageCooldown.Default);

		public bool Enabled { get; }

		public float ExperiencePerSquareKilometre { get; }

		public float LocationDiscoveryExperience { get; }

		public float NewBiomeExperience { get; }

		public float LandRadiusAt100 { get; }

		public float WeatherPenaltyReductionAt100 { get; }

		public float NightPenaltyReductionAt100 { get; }

		public int VantageLevel { get; }

		public float VantageCooldown { get; }

		public SkillValues(bool enabled, float experiencePerSquareKilometre, float locationDiscoveryExperience, float newBiomeExperience, float landRadiusAt100, float weatherPenaltyReductionAt100, float nightPenaltyReductionAt100, int vantageLevel, float vantageCooldown)
		{
			Enabled = enabled;
			ExperiencePerSquareKilometre = experiencePerSquareKilometre;
			LocationDiscoveryExperience = locationDiscoveryExperience;
			NewBiomeExperience = newBiomeExperience;
			LandRadiusAt100 = landRadiusAt100;
			WeatherPenaltyReductionAt100 = weatherPenaltyReductionAt100;
			NightPenaltyReductionAt100 = nightPenaltyReductionAt100;
			VantageLevel = vantageLevel;
			VantageCooldown = vantageCooldown;
		}

		public SkillValues With(bool? enabled = null, int? vantageLevel = null)
		{
			return new SkillValues(enabled ?? Enabled, ExperiencePerSquareKilometre, LocationDiscoveryExperience, NewBiomeExperience, LandRadiusAt100, WeatherPenaltyReductionAt100, NightPenaltyReductionAt100, vantageLevel ?? VantageLevel, VantageCooldown);
		}
	}
	public static class ExplorationSkill
	{
		public const string SkillId = "meadworks_exploration";

		public const int GameType = 1828632269;

		public const string Name = "Exploration";

		public const string Description = "Uncovering the map. Widens your map radius on land and softens the loss to darkness and weather.";

		public const string TextKey = "skill_exploration";

		public const string IconPrefab = "piece_cartographytable";

		public const float VantageStillSpeed = 0.2f;

		public const float VantageStillSeconds = 3f;

		public const float VantageMinimumAltitude = 30f;

		public static float Share(float at100Percent, float level)
		{
			if (float.IsNaN(level) || float.IsNaN(at100Percent) || float.IsInfinity(at100Percent))
			{
				return 0f;
			}
			float num = Math.Min(100f, Math.Max(0f, level));
			return at100Percent / 100f * (num / 100f);
		}

		public static RadiusFactors Factors(float level, SkillValues values, float keelSeaFactor)
		{
			if (!values.Enabled)
			{
				return new RadiusFactors(keelSeaFactor, 1f, 0f, 0f);
			}
			return new RadiusFactors(keelSeaFactor, 1f + Share(values.LandRadiusAt100, level), Share(values.WeatherPenaltyReductionAt100, level), Share(values.NightPenaltyReductionAt100, level));
		}

		public static float AreaExperience(int newTexels, float texelMetres, SkillValues values)
		{
			if (!values.Enabled || newTexels <= 0 || !(texelMetres > 0f) || float.IsInfinity(texelMetres))
			{
				return 0f;
			}
			return (float)((double)newTexels * (double)texelMetres * (double)texelMetres / 1000000.0 * (double)values.ExperiencePerSquareKilometre);
		}

		public static float DiscoveryExperience(SkillValues values)
		{
			if (!values.Enabled)
			{
				return 0f;
			}
			return values.LocationDiscoveryExperience;
		}

		public static float BiomeExperience(SkillValues values)
		{
			if (!values.Enabled)
			{
				return 0f;
			}
			return values.NewBiomeExperience;
		}

		public static bool VantageUnlocked(float level, SkillValues values)
		{
			if (values.Enabled && values.VantageLevel <= 100 && !float.IsNaN(level))
			{
				return level >= (float)values.VantageLevel;
			}
			return false;
		}

		public static float VantageRadius(float currentRadius)
		{
			return currentRadius * 2f;
		}

		public static bool StandingStill(float speed, bool onGround)
		{
			if (onGround && !float.IsNaN(speed))
			{
				return speed <= 0.2f;
			}
			return false;
		}

		public static bool VantageResets(float speed, bool onGround, bool interior)
		{
			if (!interior)
			{
				return !StandingStill(speed, onGround);
			}
			return true;
		}

		public static float VantageBase(float current, float game)
		{
			if (current > 0f && !float.IsInfinity(current))
			{
				return current;
			}
			if (game > 0f && !float.IsInfinity(game))
			{
				return game;
			}
			return 0f;
		}
	}
	public sealed class VantageTracker
	{
		private float still;

		private float? lastFired;

		public bool Tick(float now, float deltaSeconds, bool moving, float altitude, float level, SkillValues values, bool radiusSteppedAside = false)
		{
			if (radiusSteppedAside || moving || float.IsNaN(deltaSeconds) || deltaSeconds < 0f)
			{
				still = 0f;
				return false;
			}
			still += deltaSeconds;
			if (still < 3f)
			{
				return false;
			}
			if (!ExplorationSkill.VantageUnlocked(level, values) || !(altitude >= 30f))
			{
				return false;
			}
			if (lastFired.HasValue && now - lastFired.Value < values.VantageCooldown)
			{
				return false;
			}
			lastFired = now;
			still = 0f;
			return true;
		}

		public void Reset()
		{
			still = 0f;
			lastFired = null;
		}
	}
}
namespace ExtraPotions.Cairn.Radius
{
	public static class SeaFactorSource
	{
		public const float MaximumFactor = 16f;

		public static float Pick(bool keelProvides, float keelFactor, bool grindstoneAvailable, bool aboard, float grindstoneFactor)
		{
			if (keelProvides && Valid(keelFactor) && keelFactor > 1f)
			{
				return keelFactor;
			}
			if (!grindstoneAvailable || !aboard)
			{
				return 1f;
			}
			if (!float.IsNaN(grindstoneFactor) && !float.IsInfinity(grindstoneFactor) && !(grindstoneFactor < 0f))
			{
				return grindstoneFactor;
			}
			return 1f;
		}

		private static bool Valid(float factor)
		{
			if (!float.IsNaN(factor) && !float.IsInfinity(factor) && factor > 0f)
			{
				return factor <= 16f;
			}
			return false;
		}
	}
	public static class ExploreCurrentValue
	{
		public const float MaximumRadius = 10000f;

		public static float Of(bool computed, float radius)
		{
			if (!computed || float.IsNaN(radius) || float.IsInfinity(radius) || radius < 0f)
			{
				return -1f;
			}
			return Math.Min(10000f, radius);
		}
	}
	public readonly struct Rgb
	{
		public float R { get; }

		public float G { get; }

		public float B { get; }

		public float Magnitude => (float)Math.Sqrt(R * R + G * G + B * B);

		public Rgb(float r, float g, float b)
		{
			R = r;
			G = g;
			B = b;
		}
	}
	public enum RadiusBiome
	{
		Other,
		Meadows,
		BlackForest,
		Plains
	}
	public sealed class RadiusInputs
	{
		public bool Interior { get; set; }

		public bool ShipNearby { get; set; }

		public Rgb DirectionalLight { get; set; }

		public Rgb AmbientLight { get; set; }

		public float FogDensity { get; set; }

		public IReadOnlyList<string> ParticleSystems { get; set; } = Array.Empty<string>();

		public float Altitude { get; set; }

		public RadiusBiome Biome { get; set; }

		public bool InForest { get; set; }

		public float ForestFactor { get; set; } = 1f;
	}
	public readonly struct RadiusValues
	{
		public static RadiusValues Defaults => new RadiusValues(CairnSettings.Radius.MinimumRadius.Default, CairnSettings.Radius.MaximumRadius.Default, CairnSettings.Radius.LandExploreRadius.Default, CairnSettings.Radius.SeaExploreRadius.Default, CairnSettings.Radius.AltitudeRadiusBonus.Default, CairnSettings.Radius.ForestRadiusPenalty.Default, CairnSettings.Radius.DaylightRadiusScale.Default, CairnSettings.Radius.WeatherRadiusScale.Default);

		public float Minimum { get; }

		public float Maximum { get; }

		public float Land { get; }

		public float Sea { get; }

		public float AltitudeBonus { get; }

		public float ForestPenalty { get; }

		public float DaylightScale { get; }

		public float WeatherScale { get; }

		public RadiusValues(float minimum, float maximum, float land, float sea, float altitudeBonus, float forestPenalty, float daylightScale, float weatherScale)
		{
			Minimum = minimum;
			Maximum = maximum;
			Land = land;
			Sea = sea;
			AltitudeBonus = altitudeBonus;
			ForestPenalty = forestPenalty;
			DaylightScale = daylightScale;
			WeatherScale = weatherScale;
		}

		public RadiusValues With(float? minimum = null, float? maximum = null, float? land = null, float? sea = null)
		{
			return new RadiusValues(minimum ?? Minimum, maximum ?? Maximum, land ?? Land, sea ?? Sea, AltitudeBonus, ForestPenalty, DaylightScale, WeatherScale);
		}

		public RadiusValues Held()
		{
			float? maximum = Math.Min(Maximum, 2000f);
			float? land = Math.Min(Land, 200f);
			float? sea = Math.Min(Sea, 300f);
			return With(null, maximum, land, sea);
		}
	}
	public readonly struct RadiusFactors
	{
		public static RadiusFactors None => new RadiusFactors(1f, 1f, 0f, 0f);

		public float Sea { get; }

		public float Land { get; }

		public float WeatherReduction { get; }

		public float NightReduction { get; }

		public RadiusFactors(float sea, float land, float weatherReduction, float nightReduction)
		{
			Sea = Finite(sea, 1f, 0f, float.MaxValue);
			Land = Finite(land, 1f, 0f, float.MaxValue);
			WeatherReduction = Finite(weatherReduction, 0f, 0f, 1f);
			NightReduction = Finite(nightReduction, 0f, 0f, 1f);
		}

		internal static float Finite(float value, float fallback, float min, float max)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return Math.Min(max, Math.Max(min, value));
			}
			return fallback;
		}
	}
	public readonly struct RadiusResult
	{
		public float Radius { get; }

		public float Base { get; }

		public float Multiplier { get; }

		public float LightTerm { get; }

		public float WeatherTerm { get; }

		public float AltitudeTerm { get; }

		public float LocationTerm { get; }

		public float Factor { get; }

		public RadiusResult(float radius, float baseRadius, float multiplier, float light, float weather, float altitude, float location, float factor)
		{
			Radius = radius;
			Base = baseRadius;
			Multiplier = multiplier;
			LightTerm = light;
			WeatherTerm = weather;
			AltitudeTerm = altitude;
			LocationTerm = location;
			Factor = factor;
		}
	}
	public static class RadiusModel
	{
		public const float ShipShareRange = 21f;

		public static RadiusResult Compute(RadiusInputs inputs, RadiusValues values, RadiusFactors factors)
		{
			if (inputs == null)
			{
				throw new ArgumentNullException("inputs");
			}
			float num = Clamp(values.Maximum, 0f, 10000f);
			float min = Math.Min(Clamp(values.Minimum, 0f, 10000f), num);
			float num2 = Clamp(values.Land, 0f, 2000f);
			float num3 = Clamp(values.Sea, 0f, 2000f);
			float num4 = Clamp(values.AltitudeBonus, 0f, 2f);
			float forestPenalty = Clamp(values.ForestPenalty, 0f, 1f);
			float num5 = Clamp(values.DaylightScale, 0f, 1f);
			float num6 = Clamp(values.WeatherScale, 0f, 1f);
			if (inputs.Interior)
			{
				return new RadiusResult(Math.Max(num2 * 0.2f, 10f), num2, 1f, 0f, 0f, 0f, 0f, 1f);
			}
			float num7 = (inputs.ShipNearby ? num3 : num2);
			float num8 = 1f;
			float num9 = Math.Max(inputs.DirectionalLight.Magnitude, inputs.AmbientLight.Magnitude);
			if (!IsFinite(num9))
			{
				num9 = 1f;
			}
			float num10 = (num9 - 1f) * num5;
			if (num10 < 0f)
			{
				num10 *= 1f - factors.NightReduction;
			}
			num8 += num10;
			float num11 = 0f;
			foreach (string item in inputs.ParticleSystems ?? Array.Empty<string>())
			{
				if (string.Equals(item, "Mist", StringComparison.OrdinalIgnoreCase))
				{
					num11 += 0.5f;
				}
				if (string.Equals(item, "SnowStorm", StringComparison.OrdinalIgnoreCase))
				{
					num11 += 0.7f * num9;
				}
			}
			float num12 = (0f - Clamp((IsFinite(inputs.FogDensity) ? inputs.FogDensity : 0f) * 10f + num11, 0f, 1.5f)) * num6 * (1f - factors.WeatherReduction);
			num8 += num12;
			float num13 = Clamp(IsFinite(inputs.Altitude) ? inputs.Altitude : 0f, 0f, 400f) / 100f * Math.Max(0.05f, 1f - num11);
			float num14 = num13 * num4;
			num8 += num14;
			float num15 = Location(inputs, num13, num4, forestPenalty, num5);
			num8 += num15;
			if (num8 > 5f)
			{
				num8 = 5f;
			}
			if (num8 < 0.2f)
			{
				num8 = 0.2f;
			}
			float num16 = (inputs.ShipNearby ? factors.Sea : factors.Land);
			return new RadiusResult(Clamp(num7 * num8 * num16, min, num), num7, num8, num10, num12, num14, num15, num16);
		}

		public static float Disabled(float gameRadius, bool shipNearby, RadiusFactors factors)
		{
			return ((IsFinite(gameRadius) && gameRadius > 0f) ? gameRadius : 0f) * (shipNearby ? factors.Sea : factors.Land);
		}

		private static float Location(RadiusInputs inputs, float altitude, float altitudeBonus, float forestPenalty, float daylightScale)
		{
			float num = forestPenalty + altitude * altitudeBonus * forestPenalty;
			switch (inputs.Biome)
			{
			case RadiusBiome.BlackForest:
				return 0f - num - 0.25f * daylightScale;
			case RadiusBiome.Meadows:
				if (!inputs.InForest)
				{
					return 0f;
				}
				return 0f - num;
			case RadiusBiome.Plains:
				return ((inputs.ForestFactor < 0.8f) ? (0f - num) : 0f) + 0.1f * daylightScale;
			default:
				return 0f;
			}
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static float Clamp(float value, float min, float max)
		{
			if (!IsFinite(value))
			{
				return min;
			}
			return Math.Min(max, Math.Max(min, value));
		}
	}
}
namespace ExtraPotions.Cairn.Localization
{
	public readonly struct TextKey
	{
		public string Key { get; }

		public int Arguments { get; }

		public TextKey(string key, int arguments)
		{
			Key = key;
			Arguments = arguments;
		}

		public override string ToString()
		{
			return Key;
		}
	}
	public static class CairnTextKeys
	{
		public const string HeldNotice = "held_notice";

		public const string SkillName = "skill_exploration";

		public const string SkillDescription = "skill_exploration_description";

		public const string Vantage = "vantage";

		public const string HudDay = "hud_day";

		public const string SquareComfort = "square_comfort";

		public const string SquareRested = "square_rested";

		public const string SquareNotRested = "square_not_rested";

		public const string HudHeading = "hud_heading";

		public const string HudForecast = "hud_forecast";

		public const string HudForecastWind = "hud_forecast_wind";

		public const string RadiusLine = "radius_line";

		public const string RadiusInputs = "radius_inputs";

		public const string ImportDone = "import_done";

		public const string TidyPinsDescription = "tidy_pins_description";

		public const string TempestWarning = "tempest_warning";

		public const string TempestClearing = "tempest_clearing";

		public const string TempestNotice = "tempest_notice";

		public static readonly IReadOnlyList<string> PinTypes = Array.AsReadOnly(new string[18]
		{
			"Icon0", "Icon1", "Icon2", "Icon3", "Icon4", "Death", "Bed", "Shout", "None", "Boss",
			"Player", "RandomEvent", "Ping", "EventArea", "Hildir1", "Hildir2", "Hildir3", "Memorial"
		});

		private static readonly string[] Points = new string[8] { "N", "NE", "E", "SE", "S", "SW", "W", "NW" };

		public static IReadOnlyList<TextKey> All { get; } = Array.AsReadOnly(new TextKey[60]
		{
			new TextKey("held_notice", 0),
			new TextKey("skill_exploration", 0),
			new TextKey("skill_exploration_description", 0),
			new TextKey("vantage", 0),
			new TextKey("hud_day", 1),
			new TextKey("square_comfort", 1),
			new TextKey("square_rested", 1),
			new TextKey("square_not_rested", 0),
			new TextKey("hud_heading", 2),
			new TextKey("hud_forecast", 2),
			new TextKey("hud_forecast_wind", 3),
			new TextKey("radius_line", 1),
			new TextKey("radius_inputs", 7),
			new TextKey("import_done", 2),
			new TextKey("tidy_pins_description", 0),
			new TextKey("tempest_warning", 2),
			new TextKey("tempest_clearing", 1),
			new TextKey("tempest_notice", 1),
			new TextKey(TempestEvent(TempestKind.Blizzard), 0),
			new TextKey(TempestEvent(TempestKind.Thunderstorm), 0),
			new TextKey(TempestEvent(TempestKind.LightningStorm), 0),
			new TextKey(TempestEvent(TempestKind.DenseFog), 0),
			new TextKey(TempestEvent(TempestKind.AshStorm), 0),
			new TextKey(TempestEvent(TempestKind.MeteorShower), 0),
			new TextKey("ui_close", 0),
			new TextKey("ui_on", 0),
			new TextKey("ui_off", 0),
			new TextKey("ui_tab_markers", 0),
			new TextKey("ui_tab_hud", 0),
			new TextKey("ui_tab_compass", 0),
			new TextKey("ui_tab_visibility", 0),
			new TextKey("ui_tab_map", 0),
			new TextKey("ui_markers_hint", 0),
			new TextKey("ui_shown_by_type", 1),
			new TextKey("ui_map_cursor", 0),
			new TextKey("ui_help_close", 0),
			new TextKey("ui_help_tab_markers", 0),
			new TextKey("ui_help_tab_hud", 0),
			new TextKey("ui_help_tab_compass", 0),
			new TextKey("ui_help_tab_visibility", 0),
			new TextKey("ui_help_tab_map", 0),
			new TextKey("ui_help_map_cursor", 0),
			new TextKey("ui_help_marker_type", 0),
			new TextKey("ui_help_marker_pin", 0),
			new TextKey("ui_help_marker_map", 0),
			new TextKey("ui_help_decrease", 0),
			new TextKey("ui_help_increase", 0),
			new TextKey("ui_menu_hud_settings", 0),
			new TextKey("ui_menu_markers", 0),
			new TextKey("ui_menu_hud_hide", 0),
			new TextKey("ui_menu_hud_show", 0),
			new TextKey("sleep_sleeping", 2),
			new TextKey("sleep_boost", 1),
			new TextKey("sleep_skip", 1),
			new TextKey("setting_remove", 1),
			new TextKey("setting_allow_removing", 1),
			new TextKey("help_remove", 1),
			new TextKey("help_allow_removing", 1),
			new TextKey(Setting(CairnSettings.Radius.ShowRadiusInputs), 0),
			new TextKey(SettingHelp(CairnSettings.Radius.ShowRadiusInputs), 0)
		}.Concat(from CairnModule m in Enum.GetValues(typeof(CairnModule))
			select new TextKey(StepAsideNotice.KeyOf(m), 1)).Concat(from WeatherCategory c in Enum.GetValues(typeof(WeatherCategory))
			select new TextKey(Weather(c), 0)).Concat(Points.Select((string p) => new TextKey(CompassPoint(p), 0)))
			.Concat(PinTypes.Select((string t) => new TextKey(PinType(t), 0)))
			.Concat(from s in CairnSettings.All
				where !s.Hidden && s.Section != "2 - Visibility" && s.Section != "3 - Visibility Server"
				select new TextKey(Setting(s), 0))
			.Concat(from s in CairnSettings.All
				where !s.Hidden && s.Section != "2 - Visibility" && s.Section != "3 - Visibility Server" && s != CairnSettings.Map.TidyPins
				select new TextKey(SettingHelp(s), 0))
			.Concat(from VisibilityEffect e in Enum.GetValues(typeof(VisibilityEffect))
				select new TextKey(Effect(e), 0))
			.ToArray());

		public static string TempestEvent(TempestKind kind)
		{
			return TempestToken(ExtraPotions.Cairn.Hud.TempestWarning.Token(kind) ?? kind.ToString().ToLowerInvariant());
		}

		public static string TempestToken(string token)
		{
			return "tempest_" + token;
		}

		public static string Weather(WeatherCategory category)
		{
			return "weather_" + category.ToString().ToLowerInvariant();
		}

		public static string CompassPoint(string point)
		{
			return "compass_" + point.ToLowerInvariant();
		}

		public static string Setting(CairnSetting setting)
		{
			return "setting_" + setting.Section[0] + "_" + setting.Key.ToLowerInvariant().Replace(' ', '_');
		}

		public static string Effect(VisibilityEffect effect)
		{
			return "effect_" + effect.ToString().ToLowerInvariant();
		}

		public static string SettingHelp(CairnSetting setting)
		{
			return "help_" + Setting(setting);
		}

		public static string PinType(string type)
		{
			return "pin_type_" + type.ToLowerInvariant();
		}
	}
}
namespace ExtraPotions.Cairn.Integration
{
	public enum HookKind
	{
		Method,
		Field
	}
	public enum HookStatus
	{
		Wired,
		Pending
	}
	public sealed class HookTarget
	{
		public string Module { get; }

		public string Type { get; }

		public string Member { get; }

		public HookKind Kind { get; }

		public string Signature { get; }

		public HookStatus Status { get; }

		public string Purpose { get; }

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

		public override string ToString()
		{
			return Type + "." + Member + ((Kind == HookKind.Method) ? ("(" + Signature + ")") : (" : " + Signature));
		}
	}
	public static class HookTargets
	{
		public static IReadOnlyList<HookTarget> PostProcessing { get; } = Array.AsReadOnly(new HookTarget[3]
		{
			M("Visibility", "PostProcessingBehaviour", "OnPreRender", "", HookStatus.Wired, "native post-processing command-buffer execution"),
			M("Visibility", "PostProcessingBehaviour", "TryExecuteCommandBuffer", "PostProcessingComponentCommandBuffer`1<!!0>", HookStatus.Wired, "preserved native execution when removal is off"),
			M("Visibility", "PostProcessingBehaviour", "RemoveCommandBuffer", "", HookStatus.Wired, "NoFogBruh fog and ambient command-buffer removal")
		});

		public static IReadOnlyList<HookTarget> All { get; } = Array.AsReadOnly(new HookTarget[85]
		{
			M("Radius", "Minimap", "UpdateExplore", "Single,Player", HookStatus.Wired, "transpiler replaces the m_exploreRadius read with Cairn's radius (A7); prefix and finalizer mark the natural explore scope for Exploration experience (CA04b)"),
			F("Radius", "Minimap", "m_exploreRadius", "Single", HookStatus.Wired, "the field the transpiler replaces; also the radius-off base"),
			M("Radius", "Character", "InInterior", "", HookStatus.Wired, "dungeon radius (Pathfinder interior rule)"),
			M("Radius", "Player", "GetPlayersInRange", "Vector3,Single,List`1<Player>", HookStatus.Wired, "players within 21 m"),
			M("Radius", "Player", "IsAttachedToShip", "", HookStatus.Wired, "sea radius"),
			M("Radius", "Player", "GetCurrentBiome", "", HookStatus.Wired, "location term"),
			M("Radius", "WorldGenerator", "InForest", "Vector3", HookStatus.Wired, "Meadows forest"),
			M("Radius", "WorldGenerator", "GetForestFactor", "Vector3", HookStatus.Wired, "Plains forest"),
			F("Radius", "ZoneSystem", "m_waterLevel", "Single", HookStatus.Wired, "altitude"),
			F("Radius", "EnvMan", "m_dirLight", "Light", HookStatus.Wired, "daylight term"),
			M("Radius", "EnvMan", "GetCurrentEnvironment", "", HookStatus.Wired, "weather particle systems"),
			F("Radius", "EnvSetup", "m_psystems", "GameObject[]", HookStatus.Wired, "Mist and SnowStorm names"),
			M("Radius", "Ship", "GetLocalShip", "", HookStatus.Wired, "GrindstoneSkills Sailing factor only while aboard"),
			M("Visibility", "EnvMan", "SetEnv", "EnvSetup,Single,Single,Single,Single,Single", HookStatus.Wired, "game fog density captured, distance fog removed, scene targets applied"),
			M("Visibility", "EnvMan", "Update", "", HookStatus.Wired, "snow glint removed each frame"),
			M("Visibility", "EnvMan", "SetParticleArrayEnabled", "GameObject[],Boolean", HookStatus.Wired, "mist emitters and distant fog emitters"),
			M("Visibility", "ParticleMist", "Update", "", HookStatus.Wired, "particle mist skipped and cleared"),
			F("Visibility", "ParticleMist", "m_ps", "ParticleSystem", HookStatus.Wired, "particle mist system"),
			M("Visibility", "DistantFogEmitter", "Update", "", HookStatus.Wired, "distant fog stops emitting"),
			M("Visibility", "DistantFogEmitter", "SetEmit", "Boolean", HookStatus.Wired, "distant fog stops emitting"),
			M("Visibility", "Smoke", "GetAlpha", "", HookStatus.Wired, "smoke alpha 0 or scaled by Smoke Strength (BetterFog hook)"),
			F("Visibility", "DistantFogEmitter", "m_psystems", "ParticleSystem[]", HookStatus.Wired, "fog bank systems graded by Mist Strength"),
			F("Visibility", "EnvMan", "m_currentPSystems", "GameObject[]", HookStatus.Wired, "weather fog-like systems graded by Mist Strength"),
			M("Visibility", "LocationList", "GetAllLocationLists", "", HookStatus.Wired, "biome location lists for Mistlands, cave, Ashlands and Deep North mist"),
			M("Hud", "EnvMan", "GetDayFraction", "", HookStatus.Wired, "clock time (CA06b)"),
			M("Hud", "EnvMan", "GetCurrentDay", "", HookStatus.Wired, "day number (CA06b)"),
			M("Hud", "EnvMan", "IsNight", "", HookStatus.Wired, "night fog density for the weather fallback (CA06b)"),
			F("Hud", "EnvSetup", "m_name", "String", HookStatus.Wired, "weather category by environment name (CA06b)"),
			F("Hud", "EnvSetup", "m_isWet", "Boolean", HookStatus.Wired, "rain fallback for unknown environments (CA06b)"),
			F("Hud", "EnvSetup", "m_fogDensityDay", "Single", HookStatus.Wired, "fog fallback for unknown environments (CA06b)"),
			F("Hud", "EnvSetup", "m_fogDensityNight", "Single", HookStatus.Wired, "fog fallback for unknown environments (CA06b)"),
			M("Hud", "Hud", "IsUserHidden", "", HookStatus.Wired, "hides with the game's HUD toggle (CA06b)"),
			M("Hud", "Minimap", "IsOpen", "", HookStatus.Wired, "hidden on the large map (CA06b)"),
			M("Hud", "Menu", "UpdateNavigation", "", HookStatus.Wired, "owned pause-menu entry navigation (CA07b)"),
			F("Hud", "Menu", "menuEntriesParent", "RectTransform", HookStatus.Wired, "owned settings entry parent (CA07b)"),
			F("Hud", "Menu", "m_settingsButton", "Button", HookStatus.Wired, "native kit menu-button template (CA07b)"),
			M("Skill", "Minimap", "Explore", "Vector3,Single", HookStatus.Wired, "prefix counts newly explored texels inside the natural or Vantage scope; Vantage calls it (CA04b)"),
			F("Skill", "Minimap", "m_explored", "BitArray", HookStatus.Wired, "the local player's explored texels, read before an explore"),
			M("Skill", "Minimap", "WorldToPixel", "Vector3,Int32&,Int32&", HookStatus.Wired, "explore centre texel"),
			F("Skill", "Minimap", "m_pixelSize", "Single", HookStatus.Wired, "texel size in meters for area experience"),
			F("Skill", "Minimap", "m_textureSize", "Int32", HookStatus.Wired, "explored map width in texels"),
			M("Skill", "Minimap", "DiscoverLocation", "Vector3,Minimap/PinType,String,Boolean", HookStatus.Wired, "postfix: discovery experience when a new pin was added inside a natural response (CA04b)"),
			M("Skill", "Vegvisir", "Interact", "Humanoid,Boolean,Boolean", HookStatus.Wired, "natural discovery interaction scope"),
			M("Skill", "RuneStone", "Interact", "Humanoid,Boolean,Boolean", HookStatus.Wired, "natural discovery interaction scope"),
			M("Skill", "Game", "DiscoverClosestLocation", "String,Vector3,String,Int32,Boolean,Boolean", HookStatus.Wired, "records the natural request sent to the server"),
			M("Skill", "Game", "RPC_DiscoverLocationResponse", "Int64,String,Int32,Vector3,Boolean", HookStatus.Wired, "natural response scope around the pin it adds"),
			M("Skill", "Player", "AddKnownBiome", "BiomeSector", HookStatus.Wired, "prefix reads IsBiomeKnown, postfix pays new biome experience (CA04b)"),
			M("Skill", "Player", "IsBiomeKnown", "BiomeSector", HookStatus.Wired, "biome known before AddKnownBiome"),
			M("Skill", "Character", "IsOnGround", "", HookStatus.Wired, "Vantage stands on the ground"),
			M("Skill", "Character", "GetVelocity", "", HookStatus.Wired, "Vantage stands still"),
			M("Skill", "Player", "Message", "MessageHud/MessageType,String,Int32,Sprite,Boolean", HookStatus.Wired, "Vantage notice"),
			M("Skill", "ZNetScene", "GetPrefab", "String", HookStatus.Wired, "map table prefab for the skill icon"),
			F("Skill", "Piece", "m_icon", "Sprite", HookStatus.Wired, "map table icon, read at run time (D1)"),
			F("Markers", "Minimap", "m_pins", "List`1<Minimap/PinData>", HookStatus.Wired, "the player's map pins for the Markers map (CA07a)"),
			M("Markers", "Minimap", "GetSprite", "Minimap/PinType", HookStatus.Wired, "the game's own pin icons on the Markers map"),
			M("Markers", "Minimap", "WorldToMapPoint", "Vector3,Single&,Single&", HookStatus.Wired, "pin positions on the Markers map"),
			F("Markers", "Minimap", "m_mapTexture", "Texture2D", HookStatus.Wired, "Markers map image, the game's own at runtime"),
			F("Markers", "Minimap", "m_exploredOthers", "BitArray", HookStatus.Wired, "Markers map fog of war: shared map data"),
			F("Markers", "Minimap", "m_showSharedMapData", "Boolean", HookStatus.Wired, "shared map data shown, as on the large map"),
			F("Markers", "Minimap", "m_heightTexture", "Texture2D", HookStatus.Wired, "Markers map water below the water level"),
			F("Markers", "Minimap", "m_meadowsColor", "Color", HookStatus.Wired, "biome tint in the game's map texture"),
			F("Markers", "Minimap", "m_blackforestColor", "Color", HookStatus.Wired, "biome tint in the game's map texture"),
			F("Markers", "Minimap", "m_swampColor", "Color", HookStatus.Wired, "biome tint in the game's map texture"),
			F("Markers", "Minimap", "m_mountainColor", "Color", HookStatus.Wired, "biome tint in the game's map texture"),
			F("Markers", "Minimap", "m_heathColor", "Color", HookStatus.Wired, "biome tint in the game's map texture (plains)"),
			F("Markers", "Minimap", "m_mistlandsColor", "Color", HookStatus.Wired, "biome tint in the game's map texture"),
			F("Markers", "Minimap", "m_ashlandsColor", "Color", HookStatus.Wired, "biome tint in the game's map texture"),
			F("Markers", "Minimap", "m_deepnorthColor", "Color", HookStatus.Wired, "biome tint in the game's map texture"),
			F("Markers", "Minimap/PinData", "m_type", "Minimap/PinType", HookStatus.Wired, "pin type, the marker type entry; Tidy Pins keeps player, ping and shout pins at the game's size and opacity"),
			F("Markers", "Minimap/PinData", "m_pos", "Vector3", HookStatus.Wired, "pin position, the single marker entry"),
			F("Markers", "Minimap/PinData", "m_name", "String", HookStatus.Wired, "pin label"),
			F("Markers", "Minimap/PinData", "m_icon", "Sprite", HookStatus.Wired, "the pin's own icon (location pins such as the start temple have type None)"),
			F("Markers", "Minimap", "m_pinSizeLarge", "Single", HookStatus.Wired, "the large map's pin size, matched by the Markers map's pins"),
			F("Markers", "Player", "m_customData", "Dictionary`2<String,String>", HookStatus.Wired, "per-world marker choices in character data (C4)"),
			M("Markers", "ZNet", "GetWorldUID", "", HookStatus.Wired, "the world the marker choices belong to"),
			M("Import", "ZNet", "GetWorld", "", HookStatus.Wired, "match imported world names to the current world"),
			F("Import", "World", "m_name", "String", HookStatus.Wired, "source marker world name"),
			M("Import", "Player", "GetPlayerName", "", HookStatus.Wired, "source marker character name"),
			M("TidyPins", "Minimap", "Update", "", HookStatus.Wired, "restore owned visuals before native refresh, then apply local tidy-pin presentation"),
			F("TidyPins", "Minimap", "m_mode", "Minimap/MapMode", HookStatus.Wired, "names are hovered only on the large map"),
			F("TidyPins", "Minimap/PinData", "m_uiElement", "RectTransform", HookStatus.Wired, "visible icon scale and mouse/pad hit area"),
			F("TidyPins", "Minimap/PinData", "m_iconElement", "Image", HookStatus.Wired, "fade checked pin icons without changing pin data"),
			F("TidyPins", "Minimap/PinData", "m_checkedElement", "GameObject", HookStatus.Wired, "fade the checked indicator alongside its icon"),
			F("TidyPins", "Minimap/PinData", "m_checked", "Boolean", HookStatus.Wired, "read-only crossed-out state"),
			F("TidyPins", "Minimap/PinData", "m_worldSize", "Single", HookStatus.Wired, "leave event-area circles at their true world size")
		});

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

		private static HookTarget F(string module, string type, string member, string fieldType, HookStatus status, string purpose)
		{
			return new HookTarget(module, type, member, HookKind.Field, fieldType, status, purpose);
		}
	}
	public enum CairnModule
	{
		Radius,
		Visibility,
		Hud
	}
	public sealed class ModuleSource
	{
		public string Guid { get; }

		public string Name { get; }

		internal ModuleSource(string guid, string name)
		{
			Guid = guid;
			Name = name;
		}
	}
	public sealed class SourceSwitches
	{
		public static SourceSwitches Unknown => new SourceSwitches();

		public bool? TimeWeatherHudEnabled { get; set; }

		public static SourceSwitches Read(string? timeWeatherHudConfig)
		{
			SourceSwitches sourceSwitches = new SourceSwitches();
			if (timeWeatherHudConfig != null)
			{
				SourceEntry sourceEntry = SourceConfig.Parse(timeWeatherHudConfig).FirstOrDefault((SourceEntry e) => e.Section == "General" && e.Key == "Enabled");
				sourceSwitches.TimeWeatherHudEnabled = sourceEntry.Key == null || !string.Equals(sourceEntry.Value, "false", StringComparison.OrdinalIgnoreCase);
			}
			return sourceSwitches;
		}
	}
	public readonly struct StepAsideNotice
	{
		public CairnModule Module { get; }

		public string SourceNames { get; }

		public string Key => KeyOf(Module);

		public StepAsideNotice(CairnModule module, string sourceNames)
		{
			Module = module;
			SourceNames = sourceNames;
		}

		public static string KeyOf(CairnModule module)
		{
			return "step_aside_" + module.ToString().ToLowerInvariant();
		}
	}
	public sealed class StepAsideDecision
	{
		private readonly Dictionary<CairnModule, List<ModuleSource>> aside;

		public bool Any => aside.Count > 0;

		public IReadOnlyList<StepAsideNotice> Notices { get; }

		internal StepAsideDecision(Dictionary<CairnModule, List<ModuleSource>> aside)
		{
			this.aside = aside;
			Notices = (from p in aside
				orderby p.Key
				select new StepAsideNotice(p.Key, string.Join(" and ", p.Value.Select((ModuleSource s) => s.Name)))).ToList();
		}

		public bool SteppedAside(CairnModule module)
		{
			return aside.ContainsKey(module);
		}

		public IReadOnlyList<ModuleSource> SourcesOf(CairnModule module)
		{
			if (!aside.TryGetValue(module, out List<ModuleSource> value))
			{
				return Array.Empty<ModuleSource>();
			}
			return value;
		}
	}
	public static class ModuleStepAside
	{
		public static readonly ModuleSource Pathfinder = new ModuleSource("dev.crystal.pathfinder", "Pathfinder");

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

		public static readonly ModuleSource BetterFog = new ModuleSource("JevMods.BetterFog", "BetterFog");

		public static readonly ModuleSource TimeWeatherHud = new ModuleSource("lazly.valheim.timeweatherhud", "TimeWeatherHud");

		public static IReadOnlyList<ModuleSource> Sources { get; } = Array.AsReadOnly(new ModuleSource[4] { Pathfinder, NoFogBruh, BetterFog, TimeWeatherHud });

		public static StepAsideDecision Decide(IEnumerable<string> installedGuids, SourceSwitches switches)
		{
			if (installedGuids == null)
			{
				throw new ArgumentNullException("installedGuids");
			}
			SourceSwitches sourceSwitches = switches ?? SourceSwitches.Unknown;
			HashSet<string> installed = new HashSet<string>(installedGuids.Where((string g) => g != null), StringComparer.Ordinal);
			Dictionary<CairnModule, List<ModuleSource>> aside = new Dictionary<CairnModule, List<ModuleSource>>();
			Add(Pathfinder, CairnModule.Radius, acts: true);
			Add(NoFogBruh, CairnModule.Visibility, acts: true);
			Add(BetterFog, CairnModule.Visibility, acts: true);
			Add(TimeWeatherHud, CairnModule.Hud, sourceSwitches.TimeWeatherHudEnabled != false);
			return new StepAsideDecision(aside);
			void Add(ModuleSource source, CairnModule module, bool acts)
			{
				if (acts && installed.Contains(source.Guid))
				{
					if (!aside.TryGetValue(module, out List<ModuleSource> value))
					{
						value = (aside[module] = new List<ModuleSource>());
					}
					value.Add(source);
				}
			}
		}
	}
}
namespace ExtraPotions.Cairn.Hud
{
	public static class Clock
	{
		public static (int Hour, int Minute) Parts(float dayFraction)
		{
			double num = ((float.IsNaN(dayFraction) || float.IsInfinity(dayFraction)) ? 0.0 : ((double)dayFraction - Math.Floor(dayFraction))) * 24.0;
			int num2 = (int)Math.Floor(num);
			int val = (int)Math.Floor((num - (double)num2) * 60.0);
			return (Hour: Math.Min(23, Math.Max(0, num2)), Minute: Math.Min(59, Math.Max(0, val)));
		}

		public static string Text(float dayFraction, bool use24Hour)
		{
			var (num, num2) = Parts(dayFraction);
			if (use24Hour)
			{
				return num.ToString("00", CultureInfo.InvariantCulture) + ":" + num2.ToString("00", CultureInfo.InvariantCulture);
			}
			return ((num % 12 == 0) ? 12 : (num % 12)).ToString(CultureInfo.InvariantCulture) + ":" + num2.ToString("00", CultureInfo.InvariantCulture) + ((num < 12) ? " AM" : " PM");
		}
	}
	public static class ColumnSquares
	{
		public const int ComfortRank = 500;

		public const string ComfortId = "cairn_comfort";

		public static string Comfort(int level, float restedSeconds)
		{
			string text = Rested(restedSeconds);
			string text2 = Math.Max(0, level).ToString(CultureInfo.InvariantCulture);
			if (text.Length != 0)
			{
				return text2 + "\n" + text;
			}
			return text2;
		}

		public static string Rested(float seconds)
		{
			if (float.IsNaN(seconds) || float.IsInfinity(seconds) || seconds <= 0f)
			{
				return "";
			}
			int num = (int)Math.Ceiling(seconds);
			return (num / 60).ToString(CultureInfo.InvariantCulture) + ":" + (num % 60).ToString("00", CultureInfo.InvariantCulture);
		}
	}
	public readonly struct MarkerPin
	{
		public string Id { get; }

		public float X { get; }

		public float Z { get; }

		public MarkerPin(string id, float x, float z)
		{
			Id = id;
			X = x;
			Z = z;
		}
	}
	public readonly struct StripPosition
	{
		public float Offset { get; }

		public bool Parked { get; }

		public StripPosition(float offset, bool parked)
		{
			Offset = offset;
			Parked = parked;
		}
	}
	public readonly struct StripTick
	{
		public int Degrees { get; }

		public string Label { get; }

		public float Offset { get; }

		public bool North => Degrees == 0;

		public bool Major => Degrees % 45 == 0;

		public StripTick(int degrees, string label, float offset)
		{
			Degrees = degrees;
			Label = label;
			Offset = offset;
		}
	}
	public enum StripMarkKind
	{
		Minor,
		Number,
		Point
	}
	public readonly struct StripMark
	{
		public int Degrees { get; }

		public StripMarkKind Kind { get; }

		public float Offset { get; }

		public StripMark(int degrees, StripMarkKind kind, float offset)
		{
			Degrees = degrees;
			Kind = kind;
			Offset = offset;
		}
	}
	public static class Compass
	{
		public const int MarkStep = 5;

		private static readonly string[] Points = new string[8] { "N", "NE", "E", "SE", "S", "SW", "W", "NW" };

		public const int TickStep = 15;

		public const float MinFade = 0.25f;

		public const float ParkedAlpha = 0.55f;

		public static float EdgeFade(float offset, int width)
		{
			float num = (float)Math.Max(1, width) / 2f;
			float num2 = Math.Min(1f, Math.Abs(offset) / num);
			if (num2 <= 0.7f)
			{
				return 1f;
			}
			return 1f - (num2 - 0.7f) / 0.3f * 0.75f;
		}

		public static float MarkerAlpha(bool parked, float offset, int width)
		{
			if (!parked)
			{
				return EdgeFade(offset, width);
			}
			return 0.55f;
		}

		public static float Heading(float x, float z)
		{
			if (x == 0f && z == 0f)
			{
				return 0f;
			}
			return Wrap360((float)(Math.Atan2(x, z) * 180.0 / Math.PI));
		}

		public static float Bearing(float fromX, float fromZ, float toX, float toZ)
		{
			return Heading(toX - fromX, toZ - fromZ);
		}

		public static float Distance(float fromX, float fromZ, float toX, float toZ)
		{
			float num = toX - fromX;
			float num2 = toZ - fromZ;
			return (float)Math.Sqrt(num * num + num2 * num2);
		}

		public static int Degrees(float heading)
		{
			return (int)Math.Round(Wrap360(heading), MidpointRounding.AwayFromZero) % 360;
		}

		public static string Point(float heading)
		{
			return Points[(int)Math.Round(Wrap360(heading) / 45f, MidpointRounding.AwayFromZero) % 8];
		}

		public static string DistanceText(float metres)
		{
			if (!(metres >= 0f) || float.IsInfinity(metres))
			{
				return "";
			}
			if (!(metres < 1000f))
			{
				return (metres / 1000f).ToString("0.0", CultureInfo.InvariantCulture) + " km";
			}
			return Math.Round(metres, MidpointRounding.AwayFromZero).ToString("0", CultureInfo.InvariantCulture) + " m";
		}

		public static StripPosition OnStrip(float bearing, float heading, int stripDegrees, int width)
		{
			int num = Math.Max(1, stripDegrees);
			float num2 = (float)num / 2f;
			float num3 = Delta(bearing, heading);
			bool parked = Math.Abs(num3) > num2;
			return new StripPosition(Math.Max(0f - num2, Math.Min(num2, num3)) / (float)num * (float)width, parked);
		}

		public static IEnumerable<StripTick> Ticks(float heading, int stripDegrees, int width = 0)
		{
			int span = Math.Max(1, stripDegrees);
			float half = (float)span / 2f;
			int num = (int)Math.Ceiling((heading - half) / 15f) * 15;
			for (int d = num; (float)d <= heading + half + 0.0001f; d += 15)
			{
				int num2 = (d % 360 + 360) % 360;
				string label = ((num2 % 45 == 0) ? Points[num2 / 45] : num2.ToString(CultureInfo.InvariantCulture));
				yield return new StripTick(num2, label, ((float)d - heading) / (float)span * (float)width);
			}
		}

		public static IEnumerable<StripMark> Marks(float heading, int stripDegrees, int width)
		{
			int span = Math.Max(1, stripDegrees);
			float half = (float)span / 2f;
			int num = (int)Math.Ceiling((heading - half) / 5f) * 5;
			for (int d = num; (float)d <= heading + half + 0.0001f; d += 5)
			{
				int num2 = (d % 360 + 360) % 360;
				StripMarkKind kind = ((num2 % 45 == 0) ? StripMarkKind.Point : ((num2 % 15 == 0) ? StripMarkKind.Number : StripMarkKind.Minor));
				yield return new StripMark(num2, kind, ((float)d - heading) / (float)span * (float)width);
			}
		}

		public static IReadOnlyList<MarkerPin> Nearest(IEnumerable<MarkerPin> pins, float x, float z, int max, float maxDistance)
		{
			return (from p in (from p in pins ?? Enumerable.Empty<MarkerPin>()
					select (Pin: p, Distance: Distance(x, z, p.X, p.Z)) into p
					where maxDistance <= 0f || p.Distance <= maxDistance
					orderby p.Distance
					select p).ThenBy<(MarkerPin, float), string>(((MarkerPin Pin, float Distance) p) => p.Pin.Id, StringComparer.Ordinal).Take(Math.Max(0, max))
				select p.Pin).ToList();
		}

		private static float Delta(float bearing, float heading)
		{
			float num = Wrap360(bearing - heading);
			if (!(num >= 180f))
			{
				return num;
			}
			return num - 360f;
		}

		private static float Wrap360(float degrees)
		{
			if (float.IsNaN(degrees) || float.IsInfinity(degrees))
			{
				return 0f;
			}
			float num = degrees % 360f;
			if (!(num < 0f))
			{
				return num;
			}
			return num + 360f;
		}
	}
	public enum HudIcon
	{
		Sun,
		Moon,
		Cloud,
		Rain,
		Storm,
		Snow,
		Mist,
		Ash,
		Boss,
		Indoors
	}
	public static class HudIcons
	{
		private const int Samples = 4;

		private static readonly double[] Arrow = new double[8] { 0.5, 0.06, 0.88, 0.9, 0.5, 0.7, 0.12, 0.9 };

		private static readonly double[] Bolt = new double[14]
		{
			0.56, 0.58, 0.4, 0.8, 0.5, 0.8, 0.44, 0.98, 0.66, 0.72,
			0.54, 0.72, 0.62, 0.58
		};

		private static readonly double[] Roof = new double[6] { 0.5, 0.1, 0.94, 0.5, 0.06, 0.5 };

		public static HudIcon Clock(bool night)
		{
			if (!night)
			{
				return HudIcon.Sun;
			}
			return HudIcon.Moon;
		}

		public static HudIcon For(WeatherCategory category, bool night)
		{
			HudIcon hudIcon = For(category);
			if (hudIcon != HudIcon.Sun)
			{
				return hudIcon;
			}
			return Clock(night);
		}

		public static HudIcon For(WeatherCategory category)
		{
			switch (category)
			{
			case WeatherCategory.Clear:
				return HudIcon.Sun;
			case WeatherCategory.Mist:
				return HudIcon.Mist;
			case WeatherCategory.Rain:
				return HudIcon.Rain;
			case WeatherCategory.Thunderstorm:
				return HudIcon.Storm;
			case WeatherCategory.Snow:
			case WeatherCategory.Blizzard:
				return HudIcon.Snow;
			case WeatherCategory.AshRain:
				return HudIcon.Ash;
			case WeatherCategory.Boss:
				return HudIcon.Boss;
			case WeatherCategory.Indoors:
				return HudIcon.Indoors;
			default:
				return HudIcon.Cloud;
			}
		}

		public static byte[] Mask(HudIcon icon, int size)
		{
			return Sampled(size, (double x, double y) => Inside(icon, x, y));
		}

		public static byte[] PlayerArrow(int size)
		{
			return Sampled(size, (double x, double y) => Polygon(x, y, Arrow));
		}

		private static byte[] Sampled(int size, Func<double, double, bool> inside)
		{
			if (size <= 0)
			{
				return Array.Empty<byte>();
			}
			byte[] array = new byte[size * size];
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					int num = 0;
					for (int k = 0; k < 4; k++)
					{
						for (int l = 0; l < 4; l++)
						{
							double arg = ((double)j + ((double)l + 0.5) / 4.0) / (double)size;
							double arg2 = ((double)i + ((double)k + 0.5) / 4.0) / (double)size;
							if (inside(arg, arg2))
							{
								num++;
							}
						}
					}
					array[i * size + j] = (byte)(num * 255 / 16);
				}
			}
			return array;
		}

		private static bool Inside(HudIcon icon, double x, double y)
		{
			switch (icon)
			{
			case HudIcon.Sun:
				if (!Disc(x, y, 0.5, 0.5, 0.2))
				{
					return Rays(x, y, 0.5, 0.5, 0.31, 0.47, 0.055, 8);
				}
				return true;
			case HudIcon.Moon:
				if (Disc(x, y, 0.5, 0.5, 0.38))
				{
					return !Disc(x, y, 0.64, 0.4, 0.31);
				}
				return false;
			case HudIcon.Cloud:
				return Cloud(x, y, 0.5, 0.5, 1.0);
			case HudIcon.Rain:
				if (!Cloud(x, y, 0.5, 0.36, 0.8) && !Bar(x, y, 0.3, 0.66, 0.3, 0.86, 0.05) && !Bar(x, y, 0.5, 0.7, 0.5, 0.9, 0.05))
				{
					return Bar(x, y, 0.7, 0.66, 0.7, 0.86, 0.05);
				}
				return true;
			case HudIcon.Storm:
				if (!Cloud(x, y, 0.5, 0.34, 0.8))
				{
					return Polygon(x, y, Bolt);
				}
				return true;
			case HudIcon.Snow:
				if (!Rays(x, y, 0.5, 0.5, 0.0, 0.44, 0.05, 6))
				{
					return Disc(x, y, 0.5, 0.5, 0.08);
				}
				return true;
			case HudIcon.Mist:
				if (!Bar(x, y, 0.14, 0.28, 0.86, 0.28, 0.055) && !Bar(x, y, 0.14, 0.5, 0.86, 0.5, 0.055))
				{
					return Bar(x, y, 0.14, 0.72, 0.86, 0.72, 0.055);
				}
				return true;
			case HudIcon.Ash:
				if (!Cloud(x, y, 0.5, 0.36, 0.8) && !Disc(x, y, 0.3, 0.8, 0.065) && !Disc(x, y, 0.5, 0.9, 0.065))
				{
					return Disc(x, y, 0.7, 0.8, 0.065);
				}
				return true;
			case HudIcon.Boss:
				if (!Bar(x, y, 0.5, 0.1, 0.5, 0.6, 0.065))
				{
					return Disc(x, y, 0.5, 0.82, 0.09);
				}
				return true;
			case HudIcon.Indoors:
				if (Polygon(x, y, Roof) || (x >= 0.2 && x <= 0.8 && y >= 0.48 && y <= 0.9))
				{
					if (x >= 0.43 && x <= 0.57 && y >= 0.62)
					{
						return !(y <= 0.9);
					}
					return true;
				}
				return false;
			default:
				return false;
			}
		}

		private static bool Disc(double x, double y, double cx, double cy, double r)
		{
			return (x - cx) * (x - cx) + (y - cy) * (y - cy) <= r * r;
		}

		private static bool Bar(double x, double y, double ax, double ay, double bx, double by, double halfWidth)
		{
			double num = bx - ax;
			double num2 = by - ay;
			double num3 = num * num + num2 * num2;
			double num4 = ((num3 <= 0.0) ? 0.0 : Math.Max(0.0, Math.Min(1.0, ((x - ax) * num + (y - ay) * num2) / num3)));
			double num5 = ax + num4 * num;
			double num6 = ay + num4 * num2;
			return (x - num5) * (x - num5) + (y - num6) * (y - num6) <= halfWidth * halfWidth;
		}

		private static bool Rays(double x, double y, double cx, double cy, double inner, double outer, double halfWidth, int count)
		{
			double num = x - cx;
			double num2 = y - cy;
			double num3 = Math.Sqrt(num * num + num2 * num2);
			if (num3 < inner || num3 > outer)
			{
				return false;
			}
			double num4 = Math.PI * 2.0 / (double)count;
			double num5 = Math.Atan2(num, 0.0 - num2);
			double num6 = Math.Round(num5 / num4) * num4;
			return num3 * Math.Abs(Math.Sin(num5 - num6)) <= halfWidth;
		}

		private static bool Cloud(double x, double y, double cx, double cy, double s)
		{
			double num = 0.5 + (x - cx) / s;
			double num2 = 0.5 + (y - cy) / s;
			if (!Disc(num, num2, 0.3, 0.6, 0.17) && !Disc(num, num2, 0.7, 0.6, 0.17) && !Disc(num, num2, 0.5, 0.46, 0.22))
			{
				if (num >= 0.3 && num <= 0.7 && num2 >= 0.5)
				{
					return num2 <= 0.77;
				}
				return false;
			}
			return true;
		}

		private static bool Polygon(double x, double y, double[] points)
		{
			bool flag = false;
			int num = points.Length / 2;
			int num2 = 0;
			int num3 = num - 1;
			while (num2 < num)
			{
				double num4 = points[2 * num2];
				double num5 = points[2 * num2 + 1];
				double num6 = points[2 * num3];
				double num7 = points[2 * num3 + 1];
				if (num5 > y != num7 > y && x < (num6 - num4) * (y - num5) / (num7 - num5) + num4)
				{
					flag = !flag;
				}
				num3 = num2++;
			}
			return flag;
		}
	}
	public enum HudRow
	{
		Status,
		Compass,
		Heading,
		Sleep,
		Tempest,
		Radius,
		RadiusInputs
	}
	public readonly struct HudOptions
	{
		public bool ShowDay { get; }

		public bool ShowTime { get; }

		public bool ShowWeather { get; }

		public bool ShowCompass { get; }

		public bool ShowHeading { get; }

		public bool ShowRadius { get; }

		public bool ShowRadiusInputs { get; }

		public bool Sleep { get; }

		public bool Forecast { get; }

		public TempestLineKind Tempest { get; }

		public HudOptions(bool showDay, bool showTime, bool showWeather, bool showCompass, bool showHeading, bool showRadius, bool showRadiusInputs, TempestLineKind tempest, bool sleep = false, bool forecast = false)
		{
			ShowDay = showDay;
			ShowTime = showTime;
			ShowWeather = showWeather;
			ShowCompass = showCompass;
			ShowHeading = showHeading;
			ShowRadius = showRadius;
			ShowRadiusInputs = showRadiusInputs;
			Tempest = tempest;
			Sleep = sleep;
			Forecast = forecast;
		}
	}
	public readonly struct HudSize
	{
		public int Width { get; }

		public int Height { get; }

		public HudSize(int width, int height)
		{
			Width = width;
			Height = height;
		}
	}
	public static class HudLayout
	{
		public const int StripCap = 22;

		public const float Scale = 1.3333334f;

		public const int TopGap = 14;

		public const int MinWidth = 240;

		public const int MaxWidth = 640;

		public const int StatusHeight = 17;

		public const int CompassRowHeight = 22;

		public const int IconSize = 15;

		public const int PointerTop = 1;

		public const int PointerHeight = 6;

		public const int TickLabelTop = 8;

		public const int TickLabelHeight = 14;

		public const int HeadingHeight = 12;

		public const int HeadingInsetWidth = 64;

		public const int HeadingInsetHeight = 14;

		public const int ExtraRowHeight = 14;

		public const int PlankPad = 5;

		public const float StatusFontSize = 12f;

		public const float StatusMinFontSize = 8f;

		public const float StatusGap = 7f;

		public const float IconGap = 3f;

		public const float StatusEffectMargin = 8f;

		public static IReadOnlyList<HudRow> Rows(HudOptions options)
		{
			List<HudRow> list = new List<HudRow>();
			if (options.ShowDay || options.ShowTime || options.ShowWeather || options.Forecast)
			{
				list.Add(HudRow.Status);
			}
			if (options.ShowCompass)
			{
				list.Add(HudRow.Compass);
			}
			if (options.ShowCompass && options.ShowHeading)
			{
				list.Add(HudRow.Heading);
			}
			if (options.Sleep)
			{
				list.Add(HudRow.Sleep);
			}
			if (options.Tempest != TempestLineKind.None)
			{
				list.Add(HudRow.Tempest);
			}
			if (options.ShowRadius)
			{
				list.Add(HudRow.Radius);
			}
			if (options.ShowRadiusInputs)
			{
				list.Add(HudRow.RadiusInputs);
			}
			return list;
		}

		public static int PlankHeight(IReadOnlyList<HudRow> rows)
		{
			int num = 0;
			bool flag = false;
			foreach (HudRow item in rows ?? Array.Empty<HudRow>())
			{
				if (!IsExtra(item))
				{
					num += RowHeight(item);
					flag = flag || item == HudRow.Heading;
				}
			}
			if (num != 0)
			{
				return num + 5 + ((!flag) ? 5 : 0);
			}
			return 0;
		}

		public static bool IsExtra(HudRow row)
		{
			if (row != HudRow.Status && row != HudRow.Compass)
			{
				return row != HudRow.Heading;
			}
			return false;
		}

		public static int RowHeight(HudRow row)
		{
			return row switch
			{
				HudRow.Status => 17, 
				HudRow.Compass => 22, 
				HudRow.Heading => 12, 
				_ => 14, 
			};
		}

		public static int Top(IReadOnlyList<HudRow> rows, HudRow row)
		{
			if (rows == null)
			{
				rows = Array.Empty<HudRow>();
			}
			int num = (IsExtra(row) ? PlankHeight(rows) : 5);
			foreach (HudRow row2 in rows)
			{
				if (row2 == row)
				{
					return num;
				}
				if (IsExtra(row2) == IsExtra(row))
				{
					num += RowHeight(row2);
				}
			}
			return num;
		}

		public static HudSize Size(IReadOnlyList<HudRow> rows, int compassWidth = 240)
		{
			if (rows == null)
			{
				rows = Array.Empty<HudRow>();
			}
			int num = PlankHeight(rows);
			bool flag = false;
			foreach (HudRow row in rows)
			{
				if (IsExtra(row))
				{
					num += RowHeight(row);
				}
				flag = flag || row == HudRow.Compass;
			}
			return new HudSize(flag ? Math.Min(640, Math.Max(240, compassWidth)) : 240, num);
		}

		public static (float Clock, float Divider, float Weather) StatusPlaces(float panelWidth, float clockGroup, float weatherGroup, float gap)
		{
			float num = panelWidth * 0.5f;
			if (clockGroup <= 0f)
			{
				return (Clock: num, Divider: num, Weather: num - weatherGroup * 0.5f);
			}
			if (weatherGroup <= 0f)
			{
				return (Clock: num - clockGroup * 0.5f, Divider: num, Weather: num);
			}
			float num2 = num - (clockGroup + 2f * gap + weatherGroup) * 0.5f;
			return (Clock: num2, Divider: num2 + clockGroup + gap, Weather: num2 + clockGroup + 2f * gap);
		}

		public static float StatusRoom(float panelWidth)
		{
			return panelWidth - 36f;
		}

		public static float WeatherTextRoom(float panelWidth, float clockGroup)
		{
			return Math.Max(0f, StatusRoom(panelWidth) - ((clockGroup > 0f) ? (clockGroup + 14f) : 0f) - 15f - 3f);
		}

		public static (float Size, bool Ellipsis) FitText(float widthAtBase, float room, float baseSize = 12f, float minSize = 8f)
		{
			if (widthAtBase <= room)
			{
				return (Size: baseSize, Ellipsis: false);
			}
			float num = ((room <= 0f) ? 0f : ((float)Math.Floor(baseSize * room / widthAtBase * 2f) / 2f));
			if (!(num >= minSize))
			{
				return (Size: minSize, Ellipsis: true);
			}
			return (Size: num, Ellipsis: false);
		}

		public static (int X, int Y) Home(int parentWidth, int shownWidth)
		{
			return (X: (parentWidth - shownWidth) / 2, Y: 14);
		}

		public static bool Visible(bool enabled, bool allowsUi, bool steppedAside, bool toggledOff, bool blocked)
		{
			if (enabled && allowsUi && !steppedAside && !toggledOff)
			{
				return !blocked;
			}
			return false;
		}

		public static bool OwnsSleep(bool enabled, bool allowsUi, bool steppedAside, bool toggledOff, bool reading)
		{
			return enabled && allowsUi && !steppedAside && !toggledOff && reading;
		}

		public static int StatusEffectsPerRow(int nativePerRow, float firstCenter, float cell, bool plankShown, float plankRight, float plankTop, float plankBottom, float rowTop, float rowBottom)
		{
			int num = Math.Max(1, nativePerRow);
			if (!plankShown || cell <= 0f || plankBottom <= rowTop || plankTop >= rowBottom)
			{
				return num;
			}
			float num2 = firstCenter - cell * 0.5f - (plankRight + 8f);
			if (num2 < 0f)
			{
				return 1;
			}
			return Math.Max(1, Math.Min(num, 1 + (int)Math.Floor(num2 / cell)));
		}
	}
	public sealed class StatusRowHold
	{
		public const int ReleaseFrames = 2;

		private bool holding;

		private int lastOpenFrame;

		public bool Holding(bool windowOpen, int frame)
		{
			if (windowOpen)
			{
				holding = true;
				lastOpenFrame = frame;
				return true;
			}
			if (holding && frame >= lastOpenFrame && frame - lastOpenFrame <= 2)
			{
				return true;
			}
			holding = false;
			return false;
		}

		public void Reset()
		{
			holding = false;
		}
	}
	public readonly struct ClockParts
	{
		public string Day { get; }

		public string Time { get; }

		public ClockParts(string day, string time)
		{
			Day = day;
			Time = time;
		}
	}
	public readonly struct HeadingParts
	{
		public string Degrees { get; }

		public string PointKey { get; }

		public HeadingParts(string degrees, string pointKey)
		{
			Degrees = degrees;
			PointKey = pointKey;
		}
	}
	public static class HudText
	{
		public static ClockParts Clock(bool showDay, bool showTime, int day, float dayFraction, bool use24Hour)
		{
			return new ClockParts(showDay ? Math.Max(0, day).ToString(CultureInfo.InvariantCulture) : "", showTime ? ExtraPotions.Cairn.Hud.Clock.Text(dayFraction, use24Hour) : "");
		}

		public static string Join(string first, string second)
		{
			if (string.IsNullOrEmpty(first))
			{
				return second ?? "";
			}
			if (string.IsNullOrEmpty(second))
			{
				return first;
			}
			return first + "  " + second;
		}

		public static string Dot(string first, string second)
		{
			if (string.IsNullOrEmpty(first))
			{
				return second ?? "";
			}
			if (string.IsNullOrEmpty(second))
			{
				return first;
			}
			return first + " · " + second;
		}

		public static string WithForecast(string? current, string? next, bool combinedFits)
		{
			if (current == null)
			{
				current = "";
			}
			if (next == null)
			{
				next = "";
			}
			if (next.Length == 0)
			{
				return current;
			}
			if (current.Length == 0 || !combinedFits)
			{
				return next;
			}
			return Dot(current, next);
		}

		public static HeadingParts Heading(float heading)
		{
			return new HeadingParts(Compass.Degrees(heading).ToString(CultureInfo.InvariantCulture), CairnTextKeys.CompassPoint(Compass.Point(heading)));
		}

		public static string RadiusArgument(RadiusResult result)
		{
			return Whole(result.Radius);
		}

		public static string[] RadiusInputArguments(RadiusResult result)
		{
			return new string[7]
			{
				Whole(result.Radius),
				Whole(result.Base),
				result.Multiplier.ToString("0.00", CultureInfo.InvariantCulture),
				Signed(result.LightTerm),
				Signed(result.WeatherTerm),
				Signed(result.AltitudeTerm),
				Signed(result.LocationTerm)
			};
		}

		private static string Whole(float value)
		{
			return Math.Round(value, MidpointRounding.AwayFromZero).ToString("0", CultureInfo.InvariantCulture);
		}

		private static string Signed(float value)
		{
			return value.ToString("+0.00;-0.00;0.00", CultureInfo.InvariantCulture);
		}
	}
	public readonly struct SleepRowCells
	{
		public const float Moon = 18f;

		public const float Bed = 20f;

		public const float Gap = 3f;

		public const float CountMinWidth = 26f;

		public const float BoostGap = 8f;

		public const float BoostWidth = 36f;

		public const float Rivet = 9f;

		public const float RivetInset = 3f;

		public const float Edge = 14f;

		public const float GroupWidth = 114f;

		public float MoonX { get; }

		public float BedX { get; }

		public float CountX { get; }

		public float CountWidth { get; }

		public float BoostX { get; }

		public SleepRowCells(float width, float height)
		{
			MoonX = Math.Max(14f, (width - 114f) / 2f);
			BedX = MoonX + 18f + 3f;
			CountX = BedX + 20f + 3f;
			CountWidth = 26f;
			BoostX = CountX + CountWidth + 8f;
		}
	}
	public static class WeatherDisplayCapability
	{
		public const string Id = "meadworks.cairn.weather_display";

		public static Version ContractVersion { get; } = new Version(1, 0);

		public static bool Showing(bool panelVisible, bool tempestRowEnabled, TempestLineKind kind)
		{
			if (panelVisible && tempestRowEnabled)
			{
				return kind != TempestLineKind.None;
			}
			return false;
		}
	}
	public sealed class MarkerChoices
	{
		public const string Header = "cairn-markers 1";

		private readonly SortedSet<string> entries;

		public static MarkerChoices Default => new MarkerChoices(new string[1] { "type:Death" });

		public static MarkerChoices Empty => new MarkerChoices(Array.Empty<string>());

		public IReadOnlyList<string> Entries => entries.ToList();

		private MarkerChoices(IEnumerable<string> entries)
		{
			this.entries = new SortedSet<string>(entries, StringComparer.Ordinal);
		}

		public bool Contains(string entry)
		{
			return entries.Contains(entry);
		}

		public MarkerChoices With(string entry)
		{
			if (!IsEntry(entry))
			{
				throw new ArgumentException("Not a marker entry: " + entry, "entry");
			}
			return new MarkerChoices(entries.Concat(new string[1] { entry }));
		}

		public MarkerChoices Without(string entry)
		{
			return new MarkerChoices(entries.Where((string e) => e != entry));
		}

		public static string DataKey(long worldId)
		{
			return "Cairn.compassMarkers." + worldId.ToString(CultureInfo.InvariantCulture);
		}

		public static string PinKey(float x, float z, string pinType)
		{
			return "pin:" + Math.Round(x, MidpointRounding.AwayFromZero).ToString("0", CultureInfo.InvariantCulture) + "," + Math.Round(z, MidpointRounding.AwayFromZero).ToString("0", CultureInfo.InvariantCulture) + "," + pinType;
		}

		public static bool IsEntry(string? entry)
		{
			if (string.IsNullOrEmpty(entry))
			{
				return false;
			}
			if (entry.StartsWith("type:", StringComparison.Ordinal))
			{
				return IsName(entry.Substring(5));
			}
			if (!entry.StartsWith("pin:", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array = entry.Substring(4).Split(',');
			if (array.Length == 3 && int.TryParse(array[0], NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result) && int.TryParse(array[1], NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out result))
			{
				return IsName(array[2]);
			}
			return false;
		}

		public string Serialize()
		{
			return string.Join("\n", new string[1] { "cairn-markers 1" }.Concat(entries));
		}

		public static MarkerChoices Parse(string? text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return Default;
			}
			List<string> list = (from l in text.Replace("\r", "").Split('\n')
				select l.Trim() into l
				where l.Length > 0
				select l).ToList();
			if (list.Count == 0 || list[0] != "cairn-markers 1")
			{
				return Default;
			}
			return new MarkerChoices(list.Skip(1).Where(IsEntry));
		}

		private static bool IsName(string name)
		{
			if (name.Length > 0)
			{
				return name.All((char c) => char.IsLetterOrDigit(c) || c == '_');
			}
			return false;
		}
	}
	public sealed class MapPinInfo
	{
		public string Type { get; }

		public float X { get; }

		public float Z { get; }

		public string Name { get; }

		public MapPinInfo(string type, float x, float z, string name)
		{
			Type = (type ?? "").Trim();
			X = x;
			Z = z;
			Name = name ?? "";
		}
	}
	public enum MarkerShown
	{
		Hidden,
		ByType,
		ByPin
	}
	public sealed class MarkerMapPin
	{
		public MapPinInfo Pin { get; }

		public string Entry { get; }

		public MarkerShown Shown { get; }

		internal MarkerMapPin(MapPinInfo pin, string entry, MarkerShown shown)
		{
			Pin = pin;
			Entry = entry;
			Shown = shown;
		}
	}
	public sealed class MarkerTypeGroup
	{
		public string Type { get; }

		public int Count { get; }

		public bool Chosen { get; }

		public string Entry => TypeEntry(Type);

		internal MarkerTypeGroup(string type, int count, bool chosen)
		{
			Type = type;
			Count = count;
			Chosen = chosen;
		}

		internal static string TypeEntry(string type)
		{
			return "type:" + type;
		}
	}
	public readonly struct MarkerToggle
	{
		public MarkerChoices Choices { get; }

		public bool Changed { get; }

		public bool ShownByType { get; }

		public MarkerToggle(MarkerChoices choices, bool changed, bool shownByType)
		{
			Choices = choices;
			Changed = changed;
			ShownByType = shownByType;
		}
	}
	public sealed class MarkerMapPlan
	{
		public IReadOnlyList<MarkerMapPin> Pins { get; }

		public IReadOnlyList<MarkerTypeGroup> Types { get; }

		private MarkerMapPlan(IReadOnlyList<MarkerMapPin> pins, IReadOnlyList<MarkerTypeGroup> types)
		{
			Pins = pins;
			Types = types;
		}

		public static MarkerMapPlan Build(IEnumerable<MapPinInfo> pins, MarkerChoices choices)
		{
			if (pins == null)
			{
				throw new ArgumentNullException("pins");
			}
			if (choices == null)
			{
				throw new ArgumentNullException("choices");
			}
			List<MapPinInfo> list = pins.Where((MapPinInfo p) => p != null && Finite(p.X) && Finite(p.Z) && MarkerChoices.IsEntry(MarkerTypeGroup.TypeEntry(p.Type))).OrderBy<MapPinInfo, string>((MapPinInfo p) => p.Type, StringComparer.Ordinal).ThenBy<MapPinInfo, string>((MapPinInfo p) => p.Name, StringComparer.OrdinalIgnoreCase)
				.ThenBy((MapPinInfo p) => p.X)
				.ThenBy((MapPinInfo p) => p.Z)
				.ToList();
			List<MarkerMapPin> list2 = new List<MarkerMapPin>(list.Count);
			foreach (MapPinInfo item in list)
			{
				string entry = MarkerChoices.PinKey(item.X, item.Z, item.Type);
				MarkerShown shown = (choices.Contains(MarkerTypeGroup.TypeEntry(item.Type)) ? MarkerShown.ByType : (choices.Contains(entry) ? MarkerShown.ByPin : MarkerShown.Hidden));
				list2.Add(new MarkerMapPin(item, entry, shown));
			}
			List<MarkerTypeGroup> list3 = (from g in list.GroupBy<MapPinInfo, string>((MapPinInfo p) => p.Type, StringComparer.Ordinal)
				select new MarkerTypeGroup(g.Key, g.Count(), choices.Contains(MarkerTypeGroup.TypeEntry(g.Key)))).ToList();
			return new MarkerMapPlan(list2.AsReadOnly(), list3.AsReadOnly());
		}

		public MarkerToggle Toggle(int index, MarkerChoices choices)
		{
			if (choices == null)
			{
				throw new ArgumentNullException("choices");
			}
			if (index < 0 || index >= Pins.Count)
			{
				return new MarkerToggle(choices, changed: false, shownByType: false);
			}
			MarkerMapPin markerMapPin = Pins[index];
			if (choices.Contains(MarkerTypeGroup.TypeEntry(markerMapPin.Pin.Type)))
			{
				return new MarkerToggle(choices, changed: false, shownByType: true);
			}
			return new MarkerToggle(choices.Contains(markerMapPin.Entry) ? choices.Without(markerMapPin.Entry) : choices.With(markerMapPin.Entry), changed: true, shownByType: false);
		}

		public MarkerChoices ToggleType(string type, MarkerChoices choices)
		{
			if (choices == null)
			{
				throw new ArgumentNullException("choices");
			}
			string entry = MarkerTypeGroup.TypeEntry((type ?? "").Trim());
			if (!MarkerChoices.IsEntry(entry))
			{
				return choices;
			}
			if (!choices.Contains(entry))
			{
				return choices.With(entry);
			}
			return choices.Without(entry);
		}

		private static bool Finite(float v)
		{
			if (!float.IsNaN(v))
			{
				return !float.IsInfinity(v);
			}
			return false;
		}
	}
	public static class MarkerMapImage
	{
		public const uint Fog = 11574129u;

		public const uint Water = 4481132u;

		public const float StartZoom = 8f;

		public const float LargePinSize = 48f;

		public const float ArrowSize = 22f;

		public const float DimmedAlpha = 0.7f;

		public static float PinSize(float largeMapPinSize)
		{
			if (!float.IsNaN(largeMapPinSize) && !float.IsInfinity(largeMapPinSize) && !(largeMapPinSize <= 0f))
			{
				return largeMapPinSize;
			}
			return 48f;
		}

		public static float PlayerRotation(float heading)
		{
			if (float.IsNaN(heading) || float.IsInfinity(heading))
			{
				return 0f;
			}
			float num = 0f - heading % 360f;
			if (num <= -180f)
			{
				num += 360f;
			}
			if (num > 180f)
			{
				num -= 360f;
			}
			if (num != 0f)
			{
				return num;
			}
			return 0f;
		}

		public static (float X, float Y, float Zoom) StartView(float playerX, float playerY)
		{
			if (float.IsNaN(playerX) || float.IsInfinity(playerX) || float.IsNaN(playerY) || float.IsInfinity(playerY) || !(playerX >= 0f) || !(playerX <= 1f) || !(playerY >= 0f) || !(playerY <= 1f))
			{
				return (X: 0.5f, Y: 0.5f, Zoom: 1f);
			}
			return (X: playerX, Y: playerY, Zoom: 8f);
		}

		public static IReadOnlyDictionary<uint, uint> Palette(uint meadows, uint blackForest, uint swamp, uint mountain, uint plains, uint mistlands, uint ashLands, uint deepNorth)
		{
			Dictionary<uint, uint> map = new Dictionary<uint, uint>();
			Add(meadows, 8031302u);
			Add(blackForest, 4346426u);
			Add(swamp, 6444094u);
			Add(mountain, 13816525u);
			Add(plains, 12232796u);
			Add(mistlands, 6053992u);
			Add(ashLands, 7879212u);
			Add(deepNorth, 14476008u);
			return map;
			void Add(uint tint, uint painted)
			{
				if (!map.ContainsKey(tint & 0xFFFFFF))
				{
					map.Add(tint & 0xFFFFFF, painted);
				}
			}
		}

		public static void Compose(byte[] rgba, int count, Func<int, uint> biome, Func<int, bool> explored, Func<int, float> height, float waterLevel, IReadOnlyDictionary<uint, uint> palette)
		{
			if (rgba == null || biome == null || explored == null || height == null || palette == null)
			{
				throw new ArgumentNullException("rgba");
			}
			if (count < 0 || rgba.Length < count * 4)
			{
				throw new ArgumentException("The pixel buffer is shorter than the map.", "rgba");
			}
			for (int i = 0; i < count; i++)
			{
				uint num;
				if (!explored(i))
				{
					num = 11574129u;
				}
				else if (height(i) < waterLevel)
				{
					num = 4481132u;
				}
				else
				{
					uint num2 = biome(i) & 0xFFFFFF;
					num = (palette.TryGetValue(num2, out var value) ? value : num2);
				}
				int num3 = i * 4;
				rgba[num3] = (byte)(num >> 16);
				rgba[num3 + 1] = (byte)(num >> 8);
				rgba[num3 + 2] = (byte)num;
				rgba[num3 + 3] = byte.MaxValue;
			}
		}
	}
	public readonly struct SleepDisplay
	{
		public const string CapabilityId = "meadworks.cairn.sleep_display";

		public static Version ContractVersion { get; } = new Version(1, 0);

		public bool Visible { get; }

		public string Sleeping { get; }

		public string Players { get; }

		public string BoostPercent { get; }

		public string SkipPercent { get; }

		public SleepDisplay(bool windowOpen, int players, int sleeping, double extraRate, bool skipRunning, float skipProgress)
		{
			Visible = players > 0 && (skipRunning || (windowOpen && sleeping > 0));
			Players = Math.Max(0, players).ToString(CultureInfo.InvariantCulture);
			Sleeping = Math.Max(0, Math.Min(players, sleeping)).ToString(CultureInfo.InvariantCulture);
			double num = ((extraRate > 0.0 && players > 1) ? Math.Min(1.0, (double)sleeping / (double)(players - 1)) : 0.0);
			BoostPercent = Math.Max(0.0, 100.0 * num).ToString("F0", CultureInfo.InvariantCulture);
			SkipPercent = (skipRunning ? (100f * Math.Max(0f, Math.Min(1f, skipProgress))).ToString("F0", CultureInfo.InvariantCulture) : "");
		}
	}
	public static class SleepRowLayout
	{
		public const float Height = 40f;

		public const float Gap = 1f;

		public static readonly byte[] BoostColour = new byte[3] { 255, 183, 91 };
	}
	public enum TempestKind
	{
		None,
		Blizzard,
		Thunderstorm,
		LightningStorm,
		DenseFog,
		AshStorm,
		MeteorShower
	}
	public enum TempestGlyph
	{
		None,
		Snowflake,
		Bolt,
		Cloud,
		Star
	}
	public enum TempestPhase
	{
		Idle,
		Warning,
		Active,
		Clearing
	}
	public enum TempestLineKind
	{
		None,
		Warning,
		Active,
		Clearing
	}
	public readonly struct TempestLine
	{
		public static TempestLine None => new TempestLine(TempestLineKind.None, "", "", "");

		public TempestLineKind Kind { get; }

		public string TextKey { get; }

		public string EventKey { get; }

		public string Countdown { get; }

		public TempestGlyph Glyph { get; }

		public TempestLine(TempestLineKind kind, string textKey, string eventKey, string countdown, TempestGlyph glyph = TempestGlyph.None)
		{
			Kind = kind;
			TextKey = textKey;
			EventKey = eventKey;
			Countdown = countdown;
			Glyph = glyph;
		}
	}
	public static class TempestWarning
	{
		public static readonly string[] Tokens = new string[6] { "blizzard", "thunderstorm", "lightning_storm", "dense_fog", "ash_storm", "meteor_shower" };

		public static bool Reaches(int biomes, int localBiome, bool localAffected)
		{
			if (!localAffected)
			{
				return (biomes & localBiome) != 0;
			}
			return true;
		}

		public static TempestLine Line(bool enabled, TempestKind kind, TempestPhase phase, float secondsLeft, int biomes, int localBiome, bool localAffected, string? token = null)
		{
			if (!enabled || !Reaches(biomes, localBiome, localAffected))
			{
				return TempestLine.None;
			}
			string text = Token(kind);
			string text2;
			if (token != null && Array.IndexOf<string>(Tokens, token) >= 0)
			{
				text2 = CairnTextKeys.TempestToken(token);
			}
			else
			{
				if (text == null)
				{
					return TempestLine.None;
				}
				text2 = CairnTextKeys.TempestEvent(kind);
			}
			TempestGlyph glyph = GlyphOf((text != null) ? kind : KindOf(token));
			return phase switch
			{
				TempestPhase.Warning => new TempestLine(TempestLineKind.Warning, "tempest_warning", text2, Countdown(secondsLeft), glyph), 
				TempestPhase.Active => new TempestLine(TempestLineKind.Active, text2, text2, "", glyph), 
				TempestPhase.Clearing => new TempestLine(TempestLineKind.Clearing, "tempest_clearing", text2, "", glyph), 
				_ => TempestLine.None, 
			};
		}

		public static string? Token(TempestKind kind)
		{
			if (kind <= TempestKind.None || (int)kind > Tokens.Length)
			{
				return null;
			}
			return Tokens[(int)(kind - 1)];
		}

		private static TempestKind KindOf(string token)
		{
			return (TempestKind)(Array.IndexOf(Tokens, token) + 1);
		}

		public static (string Key, TempestGlyph Glyph)? StatusEvent(WeatherCategory category, string? environment, TempestLine line)
		{
			if (category == WeatherCategory.Indoors || category == WeatherCategory.Boss)
			{
				return null;
			}
			string text = WeatherCategories.EventToken(environment);
			if (text != null)
			{
				return (CairnTextKeys.TempestToken(text), GlyphOf(KindOf(text)));
			}
			if (line.Kind == TempestLineKind.Active)
			{
				return (line.EventKey, line.Glyph);
			}
			return null;
		}

		public static TempestGlyph GlyphOf(TempestKind kind)
		{
			switch (kind)
			{
			case TempestKind.Blizzard:
				return TempestGlyph.Snowflake;
			case TempestKind.Thunderstorm:
			case TempestKind.LightningStorm:
				return TempestGlyph.Bolt;
			case TempestKind.DenseFog:
				return TempestGlyph.Cloud;
			case TempestKind.AshStorm:
			case TempestKind.MeteorShower:
				return TempestGlyph.Star;
			default:
				return TempestGlyph.None;
			}
		}

		public static string Countdown(float seconds)
		{
			if (float.IsNaN(seconds) || float.IsInfinity(seconds) || seconds <= 0f)
			{
				return "0:00";
			}
			int num = (int)Math.Ceiling(Math.Min(seconds, 359999f));
			return (num / 60).ToString(CultureInfo.InvariantCulture) + ":" + (num % 60).ToString("00", CultureInfo.InvariantCulture);
		}
	}
	public readonly struct TempestReading
	{
		public int Kind { get; }

		public TempestPhase Phase { get; }

		public float SecondsLeft { get; }

		public int Biomes { get; }

		public bool LocalAffected { get; }

		public int Revision { get; }

		public string Token { get; }

		public bool Running => Phase != TempestPhase.Idle;

		public TempestReading(int kind, TempestPhase phase, float secondsLeft, int biomes, bool localAffected, int revision, string token)
		{
			Kind = kind;
			Phase = phase;
			SecondsLeft = secondsLeft;
			Biomes = biomes;
			LocalAffected = localAffected;
			Revision = revision;
			Token = token ?? "";
		}
	}
	public static class TempestDetail
	{
		public const string Id = "meadworks.weather.events.detail";

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

		public const float MaximumSecondsLeft = 3600f;

		public static bool TryRead(Tuple<int, int, float, int, bool, int, string>? raw, out TempestReading reading)
		{
			reading = default(TempestReading);
			if (raw == null || !Valid(raw.Item1, raw.Item2, raw.Item3, raw.Item4, raw.Item5, raw.Item7))
			{
				return false;
			}
			reading = new TempestReading(raw.Item1, (TempestPhase)raw.Item2, raw.Item3, raw.Item4, raw.Item5, raw.Item6, raw.Item7);
			return true;
		}

		public static bool TryRead(Func<Tuple<int, int, float, int, bool, int, string>>? provider, out TempestReading reading)
		{
			reading = default(TempestReading);
			if (provider == null)
			{
				return false;
			}
			Tuple<int, int, float, int, bool, int, string> raw;
			try
			{
				raw = provider();
			}
			catch
			{
				return false;
			}
			return TryRead(raw, out reading);
		}

		private static bool Valid(int kind, int phase, float seconds, int biomes, bool local, string? token)
		{
			if (kind < 0 || phase < 0 || phase > 3 || biomes < 0)
			{
				return false;
			}
			if (float.IsNaN(seconds) || float.IsInfinity(seconds) || seconds < 0f || seconds > 3600f)
			{
				return false;
			}
			if (phase == 0)
			{
				if (kind == 0 && seconds == 0f && biomes == 0 && !local)
				{
					return string.IsNullOrEmpty(token);
				}
				return false;
			}
			if (kind == 0 || string.IsNullOrEmpty(token) || token.Length > 32)
			{
				return false;
			}
			foreach (char c in token)
			{
				if ((c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '_')
				{
					return false;
				}
			}
			return true;
		}
	}
	public sealed class TempestNotice
	{
		private int? announced;

		public static bool HudRowDrawn { get; set; }

		public static bool CentreEnabled => ShowCentre(HudRowDrawn);

		public static bool ShowCentre(bool hudRowDrawn)
		{
			return hudRowDrawn;
		}

		public bool Update(int revision, TempestPhase phase, bool relevant)
		{
			if (phase != TempestPhase.Warning || !relevant || announced == revision)
			{
				return false;
			}
			announced = revision;
			return true;
		}

		public void Reset()
		{
			announced = null;
		}
	}
	public static class TidyPinRules
	{
		public const float IconScale = 0.75f;

		public const float CheckedAlpha = 0.35f;

		public static bool KeepsGameLook(string pinType)
		{
			if (!(pinType == "Player") && !(pinType == "Ping"))
			{
				return pinType == "Shout";
			}
			return true;
		}

		public static float Scale(string pinType, bool hovered, float hoverScale)
		{
			float num = (KeepsGameLook(pinType) ? 1f : 0.75f);
			if (hovered && !float.IsNaN(hoverScale) && hoverScale > 1f)
			{
				num *= hoverScale;
			}
			return num;
		}

		public static float Alpha(string pinType, bool isChecked)
		{
			if (!isChecked || KeepsGameLook(pinType))
			{
				return 1f;
			}
			return 0.35f;
		}

		public static bool ShowsName(bool largeMap, bool hovered, bool showAll, string name)
		{
			if (largeMap && (hovered || showAll))
			{
				return !string.IsNullOrEmpty(name);
			}
			return false;
		}
	}
	public enum WeatherCategory
	{
		Clear,
		Cloudy,
		Mist,
		Rain,
		Thunderstorm,
		Snow,
		Blizzard,
		AshRain,
		Boss,
		Indoors
	}
	public static class WeatherCategories
	{
		public const float CloudyFogDensity = 0.02f;

		private static readonly Dictionary<string, WeatherCategory> Table = Build();

		private static readonly Dictionary<string, string> EventTokens = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			["Tempest_Blizzard"] = "blizzard",
			["Tempest_Whiteout"] = "blizzard",
			["Tempest_Storm"] = "thunderstorm",
			["Tempest_LightningStorm"] = "lightning_storm",
			["Tempest_Fog"] = "dense_fog",
			["Tempest_AshStorm"] = "ash_storm",
			["Tempest_MeteorShower"] = "meteor_shower"
		};

		private static readonly Dictionary<string, string> Aliases = BuildAliases();

		public static IReadOnlyDictionary<string, WeatherCategory> Known => Table;

		public static IReadOnlyDictionary<string, string> SeasonalAliases => Aliases;

		public static WeatherCategory Of(string? environment, float fogDensity, bool rainy, bool interior = false)
		{
			if (interior)
			{
				return WeatherCategory.Indoors;
			}
			if (!string.IsNullOrWhiteSpace(environment))
			{
				string key = environment.Trim();
				if (Table.TryGetValue(key, out var value))
				{
					return value;
				}
				if (Aliases.TryGetValue(key, out string value2) && Table.TryGetValue(value2, out value))
				{
					return value;
				}
			}
			if (!rainy && !(fogDensity >= 0.02f))
			{
				return WeatherCategory.Clear;
			}
			return WeatherCategory.Cloudy;
		}

		public static string BaseName(string? environment)
		{
			if (string.IsNullOrWhiteSpace(environment))
			{
				return "";
			}
			string text = environment.Trim();
			if (!Aliases.TryGetValue(text, out string value))
			{
				return text;
			}
			return value;
		}

		public static string? EventToken(string? environment)
		{
			if (environment == null || !EventTokens.TryGetValue(environment.Trim(), out string value))
			{
				return null;
			}
			return value;
		}

		private static Dictionary<string, WeatherCategory> Build()
		{
			Dictionary<string, WeatherCategory> t = new Dictionary<string, WeatherCategory>(StringComparer.OrdinalIgnoreCase);
			Add(WeatherCategory.Clear, new string[4] { "Clear", "Twilight_Clear", "Heath clear", "Mistlands_clear" });
			Add(WeatherCategory.Cloudy, new string[10] { "Darklands_dark", "Ghosts", "Morkhalla", "TheHollow", "JotunInvasion_meadows", "JotunInvasion_blackforest", "JotunInvasion_swamp", "JotunInvasion_mountain", "JotunInvasion_plains", "JotunInvasion_mistlands" });
			Add(WeatherCategory.Mist, new string[4] { "Misty", "DeepForest Mist", "Ashlands_misty", "Tempest_Fog" });
			Add(WeatherCategory.Rain, new string[4] { "Rain", "LightRain", "SwampRain", "Mistlands_rain" });
			Add(WeatherCategory.Thunderstorm, new string[7] { "ThunderStorm", "Mistlands_thunder", "nofogts", "Ashlands_storm", "Ashlands_SeaStorm", "Tempest_Storm", "Tempest_LightningStorm" });
			Add(WeatherCategory.Snow, new string[2] { "Snow", "Twilight_Snow" });
			Add(WeatherCategory.Blizzard, new string[4] { "SnowStorm", "Twilight_SnowStorm", "Tempest_Blizzard", "Tempest_Whiteout" });
			Add(WeatherCategory.AshRain, new string[6] { "Ashrain", "Ashlands_ashrain", "Ashlands_CinderRain", "Ashlands_meteorshower", "Tempest_AshStorm", "Tempest_MeteorShower" });
			Add(WeatherCategory.Boss, new string[9] { "Eikthyr", "Eikthyr_no_lightning", "GDKing", "Bonemass", "Moder", "GoblinKing", "Queen", "Fader", "DN_Bossroom" });
			Add(WeatherCategory.Indoors, new string[6] { "Caves", "CavesHildir", "Crypt", "CryptHildir", "SunkenCrypt", "InfectedMine" });
			return t;
			void Add(WeatherCategory c, params string[] names)
			{
				foreach (string key in names)
				{
					t.Add(key, c);
				}
			}
		}

		private static Dictionary<string, string> BuildAliases()
		{
			Dictionary<string, string> t = 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 t;
			void Add(string suffix, params string[] names)
			{
				foreach (string text in names)
				{
					t.Add(text + suffix, text);
				}
			}
		}
	}
	public readonly struct ForecastEntry
	{
		public string Name { get; }

		public float Weight { get; }

		public bool AshlandsOverride { get; }

		public bool DeepnorthOverride { get; }

		public ForecastEntry(string name, float weight, bool ashlandsOverride, bool deepnorthOverride)
		{
			Name = name ?? "";
			Weight = weight;
			AshlandsOverride = ashlandsOverride;
			DeepnorthOverride = deepnorthOverride;
		}
	}
	public readonly struct ForecastChange
	{
		public long Period { get; }

		public long SecondsUntil { get; }

		public string Name { get; }

		public ForecastChange(long period, long secondsUntil, string name)
		{
			Period = period;
			SecondsUntil = secondsUntil;
			Name = name ?? "";
		}
	}
	public readonly struct ForecastLine
	{
		public static ForecastLine None => new ForecastLine(visible: false, "", 0, "", 0, WeatherCategory.Clear);

		public bool Visible { get; }

		public string NameKey { get; }

		public int Minutes { get; }

		public string WindPoint { get; }

		public int WindPercent { get; }

		public WeatherCategory Category { get; }

		public ForecastLine(bool visible, string nameKey, int minutes, string windPoint, int windPercent, WeatherCategory category)
		{
			Visible = visible;
			NameKey = nameKey ?? "";
			Minutes = minutes;
			WindPoint = windPoint ?? "";
			WindPercent = windPercent;
			Category = category;
		}
	}
	public static class WeatherForecast
	{
		public const int MaxAhead = 3;

		public static long Duration(long duration)
		{
			if (duration >= 1)
			{
				return duration;
			}
			return 1L;
		}

		public static long Period(long worldSeconds, long duration)
		{
			if (worldSeconds < 0)
			{
				worldSeconds = 0L;
			}
			return worldSeconds / Duration(duration);
		}

		public static long SecondsUntilChange(long worldSeconds, long duration)
		{
			duration = Duration(duration);
			if (worldSeconds < 0)
			{
				worldSeconds = 0L;
			}
			long num = worldSeconds % duration;
			if (num != 0L)
			{
				return duration - num;
			}
			return duration;
		}

		public static int MinutesUntil(long seconds)
		{
			if (seconds <= 0)
			{
				return 0;
			}
			long num = (seconds + 59) / 60;
			if (num <= int.MaxValue)
			{
				return (int)num;
			}
			return int.MaxValue;
		}

		public static float WeightSum(IReadOnlyList<ForecastEntry>? entries)
		{
			float num = 0f;
			if (entries == null)
			{
				return 0f;
			}
			foreach (ForecastEntry entry in entries)
			{
				if (!entry.AshlandsOverride && !entry.DeepnorthOverride)
				{
					num += entry.Weight;
				}
			}
			if (float.IsNaN(num) || float.IsInfinity(num) || num < 0f)
			{
				return 0f;
			}
			return num;
		}

		public static IReadOnlyList<ForecastEntry> Filtered(IReadOnlyList<ForecastEntry>? entries, Func<string, bool>? allows, string? fallback)
		{
			if (entries == null)
			{
				entries = Array.Empty<ForecastEntry>();
			}
			if (allows == null)
			{
				return entries;
			}
			bool flag = false;
			List<ForecastEntry> list = new List<ForecastEntry>();
			foreach (ForecastEntry entry in entries)
			{
				if (allows(entry.Name ?? ""))
				{
					list.Add(entry);
				}
				else
				{
					flag = true;
				}
			}
			if (!flag)
			{
				return entries;
			}
			if (list.Count > 0)
			{
				return list;
			}
			if (string.IsNullOrEmpty(fallback))
			{
				return entries;
			}
			return new ForecastEntry[1]
			{
				new ForecastEntry(fallback, 1f, ashlandsOverride: false, deepnorthOverride: false)
			};
		}

		public static