using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Microsoft.CodeAnalysis;
using Splatform;
using TheConcernedCat.ConcernedCartographer.Atlas;
using TheConcernedCat.ConcernedCartographer.Map;
using TheConcernedCat.ConcernedCartographer.Persistence;
using TheConcernedCat.ConcernedCartographer.Reporting;
using TheConcernedCat.ConcernedCartographer.Roads;
using TheConcernedCat.ConcernedCartographer.Runtime;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("The Concerned Cat")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2026 Eren Cansunar")]
[assembly: AssemblyFileVersion("0.10.0.0")]
[assembly: AssemblyInformationalVersion("0.10.0+a23bef007a75b84282c3aa0e0043b9be468f3301")]
[assembly: AssemblyProduct("Concerned Cartographer")]
[assembly: AssemblyTitle("TheConcernedCat.ConcernedCartographer")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Weakened/ConcernedCatMods")]
[assembly: AssemblyVersion("0.10.0.0")]
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;
		}
	}
}
namespace TheConcernedCat.ConcernedCartographer
{
	[BepInPlugin("com.theconcernedcat.valheim.concernedcartographer", "Concerned Cartographer", "0.10.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.theconcernedcat.valheim.concernedcartographer";

		public const string PluginName = "Concerned Cartographer";

		public const string PluginVersion = "0.10.0";

		private CartographerRuntime? _runtime;

		private CrashReportingHub? _crashHub;

		private void Awake()
		{
			CartographerSettings settings = CartographerSettings.Bind(((BaseUnityPlugin)this).Config);
			LocalizationPersistence.Initialize(((BaseUnityPlugin)this).Logger);
			try
			{
				_crashHub = new CrashReportingHub(settings, BuildCrashContext());
				_crashHub.Attach(((BaseUnityPlugin)this).Logger);
			}
			catch (Exception exception)
			{
				_crashHub = null;
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Crash reporting unavailable this session: " + SafeLogText.Brief(exception)));
			}
			_runtime = new CartographerRuntime(settings, ((BaseUnityPlugin)this).Logger);
			MinimapManager.OnVanillaMapAvailable += HandleMapAvailable;
			MinimapManager.OnVanillaMapDataLoaded += HandleMapDataLoaded;
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new RoadToolsCommand(_runtime));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new PinToolsCommand(_runtime));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new AtlasToolsCommand(_runtime));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SurveyToolsCommand(_runtime));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new RouteToolsCommand(_runtime));
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new SyncToolsCommand(_runtime));
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Concerned Cartographer 0.10.0 loaded");
			LogEnvironment(settings);
		}

		private static string ResolveInformationalVersion()
		{
			try
			{
				return typeof(Plugin).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion ?? "0.10.0";
			}
			catch
			{
				return "0.10.0";
			}
		}

		private CrashReportContext BuildCrashContext()
		{
			string text = ResolveInformationalVersion();
			string bepInExVersion = "unknown";
			string jotunnVersion = "unknown";
			try
			{
				bepInExVersion = typeof(BaseUnityPlugin).Assembly.GetName().Version?.ToString() ?? "unknown";
				jotunnVersion = typeof(Main).Assembly.GetName().Version?.ToString() ?? "unknown";
			}
			catch
			{
			}
			return new CrashReportContext
			{
				Release = "ConcernedCartographer@" + text,
				ModVersion = "0.10.0",
				ValheimVersion = ResolveGameVersion(),
				UnityVersion = Application.unityVersion,
				BepInExVersion = bepInExVersion,
				JotunnVersion = jotunnVersion,
				RuntimeState = SampleRuntimeState
			};
		}

		private static CrashReportRuntimeState SampleRuntimeState()
		{
			bool multiplayer = false;
			bool noMap = false;
			bool mapOpen = false;
			try
			{
				multiplayer = (Object)(object)ZNet.instance != (Object)null && ZNet.instance.GetPeers().Count > 0;
			}
			catch
			{
			}
			try
			{
				noMap = (Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey("nomap");
			}
			catch
			{
			}
			try
			{
				mapOpen = Minimap.IsOpen();
			}
			catch
			{
			}
			return new CrashReportRuntimeState(multiplayer, noMap, mapOpen);
		}

		private void LogEnvironment(CartographerSettings settings)
		{
			try
			{
				string text = typeof(BaseUnityPlugin).Assembly.GetName().Version?.ToString() ?? "unknown";
				string text2 = typeof(Main).Assembly.GetName().Version?.ToString() ?? "unknown";
				string text3 = ResolveGameVersion();
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Environment: Valheim " + text3 + ", Unity " + Application.unityVersion + ", BepInEx " + text + ", Jotunn " + text2 + "."));
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Release: ConcernedCartographer@" + ResolveInformationalVersion() + "."));
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Effective config (out-of-range values are clamped to documented ranges): " + $"Enabled={settings.Enabled.Value}, " + $"CaptureConstructionActions={settings.CaptureConstructionActions.Value}, " + $"ReconcileTerrainChanges={settings.ReconcileTerrainChanges.Value}, " + $"SampleIntervalSeconds={settings.SampleIntervalSeconds.Value}, " + $"MinimumPointSpacingMeters={settings.MinimumPointSpacingMeters.Value}, " + $"MaximumStrokeGapMeters={settings.MaximumStrokeGapMeters.Value}, " + $"DuplicateSuppressionMeters={settings.DuplicateSuppressionMeters.Value}, " + $"AutosaveIntervalSeconds={settings.AutosaveIntervalSeconds.Value}, " + $"PaintThreshold={settings.PaintThreshold.Value}, " + $"PaintSampleRadius={settings.PaintSampleRadius.Value}, " + $"LineWidthPixels={settings.LineWidthPixels.Value}, " + $"DebugLogging={settings.DebugLogging.Value}, " + $"DrawCalibrationMarkers={settings.DrawCalibrationMarkers.Value}."));
			}
			catch (Exception exception)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not record environment versions: " + SafeLogText.Brief(exception)));
			}
		}

		private static string ResolveGameVersion()
		{
			try
			{
				Type typeFromHandle = typeof(Version);
				object obj = typeFromHandle.GetField("CurrentVersion", BindingFlags.Static | BindingFlags.Public)?.GetValue(null) ?? typeFromHandle.GetProperty("CurrentVersion", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
				if (obj != null)
				{
					return obj.ToString();
				}
				MethodInfo[] methods = typeFromHandle.GetMethods(BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo in methods)
				{
					if (!(methodInfo.Name != "GetVersionString") && !(methodInfo.ReturnType != typeof(string)))
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						object[] array = new object[parameters.Length];
						for (int j = 0; j < parameters.Length; j++)
						{
							array[j] = (parameters[j].HasDefaultValue ? parameters[j].DefaultValue : (parameters[j].ParameterType.IsValueType ? Activator.CreateInstance(parameters[j].ParameterType) : null));
						}
						return (methodInfo.Invoke(null, array) as string) ?? "unknown";
					}
				}
			}
			catch
			{
			}
			return "unknown";
		}

		private void HandleMapAvailable()
		{
			_runtime?.OnMapAvailable();
		}

		private void HandleMapDataLoaded()
		{
			_runtime?.OnMapDataReconstructed();
		}

		private void Update()
		{
			_runtime?.Tick(Time.unscaledDeltaTime);
		}

		private void OnApplicationQuit()
		{
			_runtime?.SaveAll();
		}

		private void OnDestroy()
		{
			MinimapManager.OnVanillaMapAvailable -= HandleMapAvailable;
			MinimapManager.OnVanillaMapDataLoaded -= HandleMapDataLoaded;
			_runtime?.Dispose();
			_runtime = null;
			_crashHub?.Dispose();
			_crashHub = null;
		}
	}
}
namespace TheConcernedCat.ConcernedCartographer.Runtime
{
	internal sealed class AtlasToolsCommand : ConsoleCommand
	{
		private readonly CartographerRuntime _runtime;

		public override string Name => "cc_atlas";

		public override string Help => "Concerned Cartographer atlas drawer and maintenance. Subcommands: status, query <text>, clear, pins on|off, cluster on|off, dirt on|off, paved on|off, view save|apply|del <name>, views, compat, backup, backups, restore <n>, support. Drawer panel: DrawerHotkey (default L) on the large map.";

		public AtlasToolsCommand(CartographerRuntime runtime)
		{
			_runtime = runtime;
		}

		public override void Run(string[] args, Terminal context)
		{
			string text;
			try
			{
				text = _runtime.ExecuteAtlasCommand(args);
			}
			catch (Exception ex)
			{
				text = "Atlas tool failed: " + ex.Message;
			}
			if (context != null)
			{
				context.AddString(text);
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string>
			{
				"status", "query", "clear", "pins", "cluster", "dirt", "paved", "view", "views", "compat",
				"backup", "backups", "restore", "support"
			};
		}
	}
	internal sealed class CartographerRuntime : IDisposable
	{
		private readonly CartographerSettings _settings;

		private readonly ManualLogSource _log;

		private readonly RoadPersistence _persistence;

		private readonly PinPersistence _pinPersistence;

		private readonly GroundPaintProbe _probe;

		private readonly RoadOverlayRenderer _renderer;

		private readonly ConstructionCapture _constructionCapture;

		private readonly PinAdapter _pinAdapter;

		private readonly RateLimitedLog _rateLimited;

		private readonly ModalInputBlock _textFocusBlock = new ModalInputBlock((Action<bool>)GUIManager.BlockInput);

		private const float RedrawDebounceSeconds = 0.5f;

		private bool _redrawPending;

		private float _redrawElapsed;

		private RoadAtlas _atlas = new RoadAtlas();

		private TerrainIntentMask _terrainIntent = new TerrainIntentMask();

		private readonly TerrainIntentPersistence _terrainIntentPersistence;

		private RoadObservationPipeline? _pipeline;

		private RoadAtlasEditor? _editor;

		private RoadSurveyor? _surveyor;

		private PinStore _pinStore = new PinStore();

		private PinCommandHandler? _pinCommands;

		private readonly PinWorkbenchPanel _workbenchPanel;

		private readonly PinDisplayController _displayController;

		private readonly AtlasDrawerPanel _drawerPanel;

		private readonly SavedViewPersistence _savedViewPersistence;

		private SavedViewStore _savedViews = new SavedViewStore();

		private readonly MapUiCoordinator _mapUi;

		private readonly CrashConsentPanel _consentPanel;

		private bool _consentPromptChecked;

		private readonly PinPalettePanel _palettePanel;

		private readonly RoutesPanel _routesPanel;

		private readonly SurveyPanel _surveyPanel;

		private readonly SharePanel _sharePanel;

		private readonly SettingsPanel _settingsPanel;

		private readonly SystemMarkersPanel _systemMarkersPanel;

		private int _drawerToken;

		private int _paletteToken;

		private int _routesToken;

		private int _surveyToken;

		private int _shareToken;

		private int _settingsToken;

		private int _systemMarkersToken;

		private int _workbenchToken;

		private readonly QuickPinInputGate _quickPinGate = new QuickPinInputGate();

		private readonly PaletteBirthTracker<PinData> _birthTracker = new PaletteBirthTracker<PinData>();

		private float _hintElapsed;

		private readonly OrphanChromeSweep _chromeSweep = new OrphanChromeSweep();

		private string _lastChromeSweepDiagnostics = "";

		private readonly DefaultPanelRule _defaultPanel = new DefaultPanelRule();

		private const float ContextGraceSeconds = 1.5f;

		private float _contextGrace;

		private readonly QuickPinCapture _quickPinCapture;

		private readonly SurveyEngine _surveyEngine = new SurveyEngine();

		private readonly SurveyScanner _surveyScanner;

		private readonly SurveyRulePersistence _surveyRulePersistence;

		private readonly SurveyRejectedPersistence _surveyRejectedPersistence;

		private readonly RoutePersistence _routePersistence;

		private readonly RouteOverlayRenderer _routeRenderer;

		private readonly OverlayPanelRelabel _overlayRelabel;

		private float _relabelElapsed;

		private RouteStore _routeStore = new RouteStore();

		private RouteCommandHandler? _routeCommands;

		private bool _routeRedrawPending;

		private float _routeRedrawElapsed;

		private readonly SyncInbox _syncInbox = new SyncInbox();

		private readonly SyncTransport _syncTransport;

		private string _authorId = "";

		private readonly CompatibilityRegistry _compatibility = new CompatibilityRegistry();

		private readonly AtlasBackupTools _backupTools;

		private long? _worldUid;

		private bool _mapReady;

		private float _autosaveElapsed;

		private bool _disposed;

		private readonly MapSessionTracker _mapSession = new MapSessionTracker();

		private string _lastRailDiagnostics = "";

		private bool _onboardingChecked;

		private string _lastToolSummary = "";

		internal PinStore Pins => _pinStore;

		internal PinAdapter PinAdapter => _pinAdapter;

		internal PinCommandHandler? PinCommands => _pinCommands;

		public CartographerRuntime(CartographerSettings settings, ManualLogSource log)
		{
			_settings = settings;
			_log = log;
			_persistence = new RoadPersistence(log);
			_terrainIntentPersistence = new TerrainIntentPersistence(log);
			_pinPersistence = new PinPersistence(log);
			_probe = new GroundPaintProbe(settings, log);
			_renderer = new RoadOverlayRenderer(settings, log);
			_rateLimited = new RateLimitedLog(log, 5f);
			_pinAdapter = new PinAdapter(log);
			_workbenchPanel = new PinWorkbenchPanel(log);
			_displayController = new PinDisplayController(log);
			_savedViewPersistence = new SavedViewPersistence(log);
			_savedViews = _savedViewPersistence.Load();
			_drawerPanel = new AtlasDrawerPanel(log);
			WireDrawer();
			_mapUi = new MapUiCoordinator(log);
			_consentPanel = new CrashConsentPanel(log, settings);
			_palettePanel = new PinPalettePanel(log);
			_routesPanel = new RoutesPanel(log, () => _routeCommands);
			_surveyPanel = new SurveyPanel(log, settings, ExecuteSurveyCommand, () => _surveyEngine.Observations, () => _surveyEngine, () => _surveyScanner);
			_sharePanel = new SharePanel(log, ExecuteSyncCommand, delegate
			{
				List<string> list = new List<string>();
				foreach (SyncInbox.Envelope envelope in _syncInbox.Envelopes)
				{
					list.Add(envelope.AuthorName);
				}
				return list;
			});
			_settingsPanel = new SettingsPanel(log, ExecuteAtlasCommand, ExecuteRoadCommand, delegate
			{
				_consentPanel.ShowSettings();
			});
			_systemMarkersPanel = new SystemMarkersPanel(log);
			_drawerToken = _mapUi.RegisterSurface(() => _drawerPanel.IsVisible, _drawerPanel.Hide);
			_paletteToken = _mapUi.RegisterSurface(() => _palettePanel.IsVisible, _palettePanel.Hide);
			_routesToken = _mapUi.RegisterSurface(() => _routesPanel.IsVisible, _routesPanel.Hide);
			_surveyToken = _mapUi.RegisterSurface(() => _surveyPanel.IsVisible, _surveyPanel.Hide);
			_shareToken = _mapUi.RegisterSurface(() => _sharePanel.IsVisible, _sharePanel.Hide);
			_settingsToken = _mapUi.RegisterSurface(() => _settingsPanel.IsVisible, _settingsPanel.Hide);
			_systemMarkersToken = _mapUi.RegisterSurface(() => _systemMarkersPanel.IsVisible, _systemMarkersPanel.Hide);
			_workbenchToken = _mapUi.RegisterSurface(() => _workbenchPanel.IsVisible, _workbenchPanel.Close);
			_mapUi.AtlasClicked = delegate
			{
				_mapUi.OpenExclusive(_drawerToken, ToggleDrawer);
			};
			_mapUi.MarkersClicked = delegate
			{
				if (PaletteActive())
				{
					_palettePanel.UiScale = _settings.UiScale.Value;
					_palettePanel.EnsureBuilt();
					_mapUi.OpenExclusive(_paletteToken, _palettePanel.Toggle);
				}
				else
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)1, "The enhanced marker palette is disabled (setting or a conflicting pin manager); the vanilla selector is shown instead.", 0, (Sprite)null);
					}
				}
			};
			_mapUi.RoutesClicked = delegate
			{
				OpenSidePanel(_routesToken, _routesPanel);
			};
			_mapUi.SurveyClicked = delegate
			{
				OpenSidePanel(_surveyToken, _surveyPanel);
			};
			_mapUi.ShareClicked = delegate
			{
				OpenSidePanel(_shareToken, _sharePanel);
			};
			_mapUi.SettingsClicked = delegate
			{
				OpenSidePanel(_settingsToken, _settingsPanel);
			};
			_mapUi.QuickPinClicked = ArmQuickPin;
			_drawerPanel.PrivacyClicked = delegate
			{
				_consentPanel.ShowSettings();
			};
			_drawerPanel.SystemMarkersClicked = delegate
			{
				OpenSidePanel(_systemMarkersToken, _systemMarkersPanel);
			};
			MapInputGate.Install(log);
			PlayerInputGate.Install(log);
			PlayerInputGate.SuppressAttack = () => _quickPinGate.SuppressAttack(Time.frameCount);
			PlayerInputGate.SuppressMenu = () => _quickPinGate.SuppressMenu(Time.frameCount);
			PinDeletionWatch.Install(log);
			PinDeletionWatch.ExplicitDelete = HandleExplicitVanillaDelete;
			MapInputGate.WheelGuard = () => Minimap.IsOpen() && (MapPointerGuard.IsPointerOverCcUi(Vector2.op_Implicit(Input.mousePosition)) || CcTextFocus.AnyFieldFocused());
			MapPointerGuard.Clear();
			MapPointerGuard.RegisterWidget(() => _mapUi.ToolbarObject);
			MapPointerGuard.RegisterWidget(() => _mapUi.ContextButtonObject);
			MapPointerGuard.RegisterWidget(() => _palettePanel.PanelObject);
			_palettePanel.IconChosen = delegate(IconRegistry.IconDefinition definition)
			{
				MinimapReflection.TrySelectIcon(definition.VanillaType);
				_birthTracker.Arm(definition.Id, definition.DefaultCategory);
			};
			_palettePanel.SelectionCleared = delegate
			{
				_birthTracker.Disarm();
			};
			_quickPinCapture = new QuickPinCapture(settings, log);
			_surveyRulePersistence = new SurveyRulePersistence(log);
			_surveyRejectedPersistence = new SurveyRejectedPersistence(log);
			_surveyEngine.Rules = _surveyRulePersistence.LoadOrCreate();
			_surveyScanner = new SurveyScanner(settings, log);
			_routePersistence = new RoutePersistence(log);
			_routeRenderer = new RouteOverlayRenderer(settings, log);
			_overlayRelabel = new OverlayPanelRelabel(log);
			_renderer.UserToggledOverlay += delegate(RoadKind kind, bool enabled)
			{
				if (kind == RoadKind.Dirt)
				{
					_settings.DrawerShowDirt.Value = enabled;
				}
				else
				{
					_settings.DrawerShowPaved.Value = enabled;
				}
			};
			_routeRenderer.UserToggled += delegate(bool enabled)
			{
				_renderer.SetRouteVectorVisible(enabled);
			};
			_authorId = AuthorIdentity.Get(log);
			_syncTransport = new SyncTransport(log, _syncInbox)
			{
				LocalAuthorId = _authorId
			};
			_backupTools = new AtlasBackupTools(log);
			_constructionCapture = new ConstructionCapture(log);
			_constructionCapture.OperationCaptured += HandleTerrainOperation;
		}

		public void OnMapAvailable()
		{
			if (_disposed)
			{
				return;
			}
			if (!WorldContext.TryGetWorldUid(out var uid))
			{
				_log.LogWarning((object)"Map became available before a world UID could be resolved; waiting for the next map event.");
				_mapReady = false;
				return;
			}
			SwitchWorld(uid);
			_mapReady = true;
			_log.LogInfo((object)string.Format("Map session lifecycle: generation {0} (map-available).", _mapSession.NoteTransition("map-available")));
			_renderer.ResetMapSession();
			_routeRenderer.ResetMapSession();
			CcIconSprites.ResetSession();
			_renderer.RedrawAll(_atlas);
			_pinAdapter.ReconcileOnMapReady(_pinStore);
			_mapSession.NoteBound();
			_renderer.SetOverlayEnabled(RoadKind.Dirt, _settings.DrawerShowDirt.Value);
			_renderer.SetOverlayEnabled(RoadKind.Paved, _settings.DrawerShowPaved.Value);
			_displayController.ShowPins = _settings.DrawerShowPins.Value;
			_displayController.ClusterEnabled = _settings.DrawerCluster.Value;
			_displayController.Apply(_pinStore, _pinAdapter);
			_routeRenderer.RedrawAll(_routeStore);
			_renderer.MarkVectorDataDirty();
			_syncTransport.EnsureRegistered();
			_compatibility.Evaluate(_log);
			ShowOnboardingOnce();
			if (_settings.DrawCalibrationMarkers.Value)
			{
				_renderer.DrawCalibrationMarkers();
			}
			_log.LogInfo((object)$"Road atlas ready: {_atlas.Strokes.Count} stroke(s), {_atlas.PointCount} point(s).");
		}

		public void OnMapDataReconstructed()
		{
			if (!_disposed)
			{
				if (!_mapReady)
				{
					OnMapAvailable();
					return;
				}
				_log.LogInfo((object)string.Format("Map session lifecycle: generation {0} (map-data-loaded).", _mapSession.NoteTransition("map-data-loaded")));
				_pinAdapter.ReconcileOnMapReady(_pinStore, "map-data-loaded");
				_mapSession.NoteBound();
				ReapplyDisplay();
			}
		}

		private void HandleExplicitVanillaDelete(PinData pin)
		{
			if (!_disposed && _mapReady)
			{
				_pinAdapter.HandleExplicitVanillaDelete(_pinStore, pin);
			}
		}

		public void Tick(float unscaledDeltaTime)
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed)
			{
				return;
			}
			_workbenchPanel.HandleFrame();
			_consentPanel.HandleFrame();
			_routesPanel.HandleFrame();
			_surveyPanel.HandleFrame();
			_sharePanel.HandleFrame();
			_settingsPanel.HandleFrame();
			_systemMarkersPanel.HandleFrame();
			_palettePanel.HandleFrame();
			if (!Minimap.IsOpen())
			{
				MapInputGate.ConsumeClicks = false;
			}
			if (!_settings.Enabled.Value || !_mapReady || _surveyor == null)
			{
				MapInputGate.ConsumeClicks = false;
				_textFocusBlock.Release();
				_quickPinGate.Disarm();
				if (!_settings.Enabled.Value)
				{
					_renderer.EnsureTextureFallback();
					_routeRenderer.TickVisibility(vectorRoutesActive: false);
					_overlayRelabel.Restore();
				}
				if (Minimap.IsOpen())
				{
					EnforceVanillaPaletteVisibility();
					_palettePanel.SetUnavailable();
				}
				if (_mapUi.AnySurfaceVisible)
				{
					_mapUi.CloseAllSurfaces();
				}
				return;
			}
			_drawerPanel.HandleFrame();
			bool flag = CcTextFocus.AnyFieldFocused();
			if (flag)
			{
				_textFocusBlock.Acquire();
			}
			else
			{
				_textFocusBlock.Release();
			}
			if (!Minimap.IsOpen() && !Minimap.InTextInput() && !flag)
			{
				if (_quickPinGate.Armed)
				{
					switch (_quickPinGate.HandleFrame(Time.frameCount, Input.GetKeyDown((KeyCode)27), Input.GetMouseButtonDown(0) || ((int)_settings.QuickPinHotkey.Value != 0 && Input.GetKeyDown(_settings.QuickPinHotkey.Value)) || GamepadDown(_settings.WorkbenchGamepadButton.Value)))
					{
					case QuickPinInputGate.FrameAction.Cancel:
					{
						Player localPlayer = Player.m_localPlayer;
						if (localPlayer != null)
						{
							((Character)localPlayer).Message((MessageType)1, AtlasStrings.Get("quickpin.cancelled"), 0, (Sprite)null);
						}
						break;
					}
					case QuickPinInputGate.FrameAction.Capture:
						CaptureQuickPin();
						break;
					}
				}
				else if ((int)_settings.QuickPinHotkey.Value != 0 && Input.GetKeyDown(_settings.QuickPinHotkey.Value))
				{
					CaptureQuickPin();
				}
			}
			if (!Minimap.IsOpen())
			{
				_defaultPanel.NoteMapClosed();
			}
			if (Minimap.IsOpen() && !Minimap.InTextInput() && !flag)
			{
				_mapUi.EnsureBuilt(((object)_settings.DrawerHotkey.Value/*cast due to .constrained prefix*/).ToString());
				if (!_consentPromptChecked)
				{
					_consentPromptChecked = true;
					if (_consentPanel.NeedsFirstRunPrompt)
					{
						_consentPanel.ShowFirstRun();
					}
				}
				if (PaletteActive())
				{
					_palettePanel.UiScale = _settings.UiScale.Value;
					_palettePanel.EnsureBuilt();
				}
				else
				{
					_palettePanel.SetUnavailable();
				}
				if (_defaultPanel.IsArmed && _defaultPanel.ShouldAutoOpen(PaletteActive() && !_mapUi.HasFailed && AtlasAccessAllowed(out string _), _mapUi.AnySurfaceVisible))
				{
					_palettePanel.UiScale = _settings.UiScale.Value;
					_palettePanel.EnsureBuilt();
					_mapUi.OpenExclusive(_paletteToken, delegate
					{
						if (!_palettePanel.IsVisible)
						{
							_palettePanel.Toggle();
						}
					});
				}
				UpdateEditHint(unscaledDeltaTime);
				if (_pinCommands != null && !_workbenchPanel.IsVisible && (Input.GetKeyDown(_settings.WorkbenchHotkey.Value) || GamepadDown(_settings.WorkbenchGamepadButton.Value)))
				{
					OpenWorkbenchAtCursor();
				}
				if (Input.GetKeyDown(_settings.DrawerHotkey.Value) || GamepadDown(_settings.DrawerGamepadButton.Value))
				{
					_mapUi.OpenExclusive(_drawerToken, ToggleDrawer);
				}
				if (_displayController.ZoomTierChanged())
				{
					_displayController.Apply(_pinStore, _pinAdapter);
				}
				bool flag2 = (MapInputGate.ConsumeClicks = _routeCommands != null && _routeCommands.Mode != RouteCommandHandler.MapMode.None && _routeCommands.UiModeOwned);
				if (flag2)
				{
					MinimapReflection.TrySuppressMapDragThisFrame();
				}
				if (_routeCommands != null && _routeCommands.Mode != RouteCommandHandler.MapMode.None && (flag2 || Input.GetKey(_settings.RouteDrawModifier.Value)) && MinimapReflection.TryScreenToWorldPoint(Input.mousePosition, out var worldPosition))
				{
					bool flag3 = MapPointerGuard.IsPointerOverCcUi(Vector2.op_Implicit(Input.mousePosition));
					_routeCommands.HandleMapFrame(new RoadPoint(worldPosition.x, worldPosition.y, worldPosition.z), Input.GetMouseButton(0) && !flag3, Input.GetMouseButtonDown(0) && !flag3);
				}
			}
			_routeRedrawElapsed += unscaledDeltaTime;
			if (_routeRedrawPending && _routeRedrawElapsed >= 0.5f)
			{
				_routeRedrawElapsed = 0f;
				_routeRedrawPending = false;
				_routeRenderer.RedrawAll(_routeStore);
				_renderer.MarkVectorDataDirty();
			}
			if (!WorldContext.TryGetWorldUid(out var uid) || _worldUid != uid)
			{
				_mapReady = false;
				_log.LogInfo((object)string.Format("Map session lifecycle: generation {0} (world-unloaded).", _mapSession.NoteTransition("world-unloaded")));
				_workbenchPanel.Close();
				_mapUi.CloseAllSurfaces();
				_drawerPanel.FlushPosition();
				MapInputGate.ConsumeClicks = false;
				_textFocusBlock.Release();
				_quickPinGate.Disarm();
				_pipeline?.EndAllStrokes();
				_displayController.Reset();
				_mapUi.Reset();
				_palettePanel.Reset();
				_chromeSweep.RestoreAll();
				_birthTracker.Reset();
				_pinAdapter.Reset();
				SaveIfDirty();
				SavePinsSnapshot();
				return;
			}
			_surveyor.Tick(unscaledDeltaTime);
			_renderer.TickVectorLayer(unscaledDeltaTime, _atlas, _routeStore);
			_routeRenderer.TickVisibility(_renderer.VectorLayerActive);
			_relabelElapsed += unscaledDeltaTime;
			if (_relabelElapsed >= 1f)
			{
				_relabelElapsed = 0f;
				if (Minimap.IsOpen())
				{
					_overlayRelabel.EnsureApplied();
				}
			}
			_surveyScanner.Tick(unscaledDeltaTime, _surveyEngine, _pinStore);
			if (_settings.EnhancedPinPalette.Value && MinimapReflection.TryGetNamePin(out PinData namePin))
			{
				PinData val = _birthTracker.Observe(namePin);
				if (val != null)
				{
					HandlePaletteBirth(val);
				}
				if (namePin != null && _birthTracker.IsArmed)
				{
					_pinAdapter.ApplyImmediateSprite(namePin, _birthTracker.IconId);
				}
			}
			_redrawElapsed += unscaledDeltaTime;
			if (_redrawPending && _redrawElapsed >= 0.5f)
			{
				_redrawPending = false;
				_redrawElapsed = 0f;
				_renderer.RedrawAll(_atlas);
			}
			_autosaveElapsed += unscaledDeltaTime;
			if (_autosaveElapsed >= _settings.AutosaveIntervalSeconds.Value)
			{
				_autosaveElapsed = 0f;
				SaveIfDirty();
				_pinAdapter.AbsorbVanillaChanges(_pinStore);
				if (_pinAdapter.NeedsRebind && _pinAdapter.IsOperational)
				{
					_pinAdapter.ReconcileOnMapReady(_pinStore, "rendering-loss-repair");
					_mapSession.NoteBound();
					ReapplyDisplay();
				}
				_pinPersistence.FlushJournal();
				_routePersistence.FlushJournal();
				SaveRejectedIfDirty();
			}
		}

		internal string ExecutePinCommand(string[] args)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!AtlasAccessAllowed(out string denial))
			{
				return denial;
			}
			if (_disposed || !_mapReady || _pinCommands == null)
			{
				return "Concerned Cartographer: no world is loaded yet.";
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer == null)
			{
				return "Concerned Cartographer: no local player.";
			}
			if (args.Length != 0 && string.Equals(args[0], "edit", StringComparison.OrdinalIgnoreCase))
			{
				OpenWorkbenchNear(((Component)localPlayer).transform.position);
				return "Opening the Pin Workbench for the nearest pin.";
			}
			return _pinCommands.Execute(args, ((Component)localPlayer).transform.position);
		}

		private void WireDrawer()
		{
			_drawerPanel.LoadPosition = () => _settings.DrawerPanelPosition.Value;
			_drawerPanel.PositionCaptured = delegate(string stored)
			{
				_settings.DrawerPanelPosition.Value = stored;
			};
			_drawerPanel.DirtToggled = delegate(bool value)
			{
				_settings.DrawerShowDirt.Value = value;
				_renderer.SetOverlayEnabled(RoadKind.Dirt, value);
			};
			_drawerPanel.PavedToggled = delegate(bool value)
			{
				_settings.DrawerShowPaved.Value = value;
				_renderer.SetOverlayEnabled(RoadKind.Paved, value);
			};
			_drawerPanel.PinsToggled = delegate(bool value)
			{
				_settings.DrawerShowPins.Value = value;
				_displayController.ShowPins = value;
				ReapplyDisplay();
			};
			_drawerPanel.ClusterToggled = delegate(bool value)
			{
				_settings.DrawerCluster.Value = value;
				_displayController.ClusterEnabled = value;
				ReapplyDisplay();
			};
			_drawerPanel.QueryApplied = delegate(string query)
			{
				_displayController.SetQuery(query);
				ReapplyDisplay();
			};
			_drawerPanel.ViewSaved = delegate(string name)
			{
				_savedViews.Save(new SavedView(name, _displayController.QueryText, _settings.DrawerShowDirt.Value, _settings.DrawerShowPaved.Value, _displayController.ShowPins, _displayController.ClusterEnabled));
				_savedViewPersistence.Save(_savedViews);
			};
			_drawerPanel.ViewApplied = delegate(string name)
			{
				ApplySavedView(name);
			};
			_drawerPanel.ResultClicked = OpenWorkbenchForId;
			_drawerPanel.StatusLine = () => $"{_displayController.VisibleCount} shown · {_displayController.HiddenByFilter} hidden · {_displayController.ClusterCount} grouped";
			_drawerPanel.TopResults = delegate
			{
				List<(string, AtlasId)> list = new List<(string, AtlasId)>();
				PinQuery pinQuery = PinQuery.Parse(_displayController.QueryText);
				foreach (AtlasPin item in _pinStore.Living)
				{
					if (!item.Archived && pinQuery.Matches(item))
					{
						list.Add(((item.Name.Length == 0) ? "(unnamed)" : item.Name, item.Id));
						if (list.Count >= 6)
						{
							break;
						}
					}
				}
				return list;
			};
			_drawerPanel.ViewNames = delegate
			{
				List<string> list = new List<string>();
				foreach (SavedView view in _savedViews.Views)
				{
					list.Add(view.Name);
					if (list.Count >= 5)
					{
						break;
					}
				}
				return list;
			};
		}

		private bool ApplySavedView(string name)
		{
			if (!_savedViews.TryGet(name, out SavedView view))
			{
				return false;
			}
			_settings.DrawerShowDirt.Value = view.ShowDirt;
			_settings.DrawerShowPaved.Value = view.ShowPaved;
			_settings.DrawerShowPins.Value = view.ShowPins;
			_settings.DrawerCluster.Value = view.ClusterEnabled;
			_renderer.SetOverlayEnabled(RoadKind.Dirt, view.ShowDirt);
			_renderer.SetOverlayEnabled(RoadKind.Paved, view.ShowPaved);
			_displayController.ShowPins = view.ShowPins;
			_displayController.ClusterEnabled = view.ClusterEnabled;
			_displayController.SetQuery(view.Query);
			ReapplyDisplay();
			return true;
		}

		private void ReapplyDisplay()
		{
			if (_mapReady)
			{
				_displayController.Apply(_pinStore, _pinAdapter);
			}
		}

		private void ResyncPins()
		{
			_pinAdapter.SyncAllPins(_pinStore, _displayController.IsDisplayHidden);
			ReapplyDisplay();
		}

		private void CaptureQuickPin()
		{
			if (_quickPinCapture.TryCapture(_pinStore, out string message, out AtlasPin created))
			{
				if (created != null)
				{
					_displayController.MarkStickyVisible(created.Id);
				}
				ResyncPins();
			}
			if (message.Length > 0)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
				}
			}
		}

		private bool PaletteActive()
		{
			if (_settings.EnhancedPinPalette.Value && !_compatibility.PinManagerPresent)
			{
				return !_palettePanel.HasFailed;
			}
			return false;
		}

		private void OpenSidePanel(int token, CcSidePanel panel)
		{
			if (!AtlasAccessAllowed(out string denial))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, denial, 0, (Sprite)null);
				}
			}
			else
			{
				panel.UiScale = _settings.UiScale.Value;
				_mapUi.OpenExclusive(token, panel.Toggle);
			}
		}

		private void ArmQuickPin()
		{
			if (!AtlasAccessAllowed(out string denial))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, denial, 0, (Sprite)null);
				}
				return;
			}
			try
			{
				_mapUi.CloseAllSurfaces();
				Minimap instance = Minimap.instance;
				if (instance != null)
				{
					instance.SetMapMode((MapMode)1);
				}
			}
			catch
			{
			}
			_quickPinGate.Arm(Time.frameCount);
			Player localPlayer2 = Player.m_localPlayer;
			if (localPlayer2 != null)
			{
				((Character)localPlayer2).Message((MessageType)2, AtlasStrings.Get("quickpin.armed"), 0, (Sprite)null);
			}
		}

		private void ToggleDrawer()
		{
			if (AtlasAccessAllowed(out string denial))
			{
				_drawerPanel.UiScale = _settings.UiScale.Value;
				_drawerPanel.Toggle(_settings.DrawerShowDirt.Value, _settings.DrawerShowPaved.Value, _settings.DrawerShowPins.Value, _settings.DrawerCluster.Value);
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, denial, 0, (Sprite)null);
			}
		}

		private void UpdateEditHint(float unscaledDeltaTime)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			_hintElapsed += unscaledDeltaTime;
			if (_hintElapsed < 0.2f)
			{
				return;
			}
			_hintElapsed = 0f;
			EnforceVanillaPaletteVisibility();
			_mapUi.UpdateLayout();
			if (_workbenchPanel.IsVisible)
			{
				_mapUi.SetHint(null);
				_mapUi.SetContext(null, null);
				return;
			}
			PinData pin = null;
			Vector3 worldPosition;
			float distance;
			bool flag = MinimapReflection.TryScreenToWorldPoint(Input.mousePosition, out worldPosition) && _pinAdapter.TryFindNearest(worldPosition, 30f, out pin, out distance);
			if (flag && _pinAdapter.TryGetManagedId(pin, out var id))
			{
				_contextGrace = 1.5f;
				_mapUi.SetHint(AtlasStrings.Format("hud.editHint", _settings.WorkbenchHotkey.Value));
				AtlasId captured = id;
				_mapUi.SetContext(AtlasStrings.Get("hud.editPin"), delegate
				{
					OpenWorkbenchForId(captured);
				});
			}
			else if (flag && _pinAdapter.IsAdoptableVanilla(pin) && !_compatibility.PinManagerPresent)
			{
				_contextGrace = 1.5f;
				_mapUi.SetHint(AtlasStrings.Format("hud.editHint", _settings.WorkbenchHotkey.Value));
				PinData capturedPin = pin;
				_mapUi.SetContext(AtlasStrings.Get("hud.upgradeEdit"), delegate
				{
					UpgradeAndEdit(capturedPin);
				});
			}
			else if (!_mapUi.PointerOverContext)
			{
				_contextGrace -= 0.2f;
				if (!(_contextGrace > 0f))
				{
					_mapUi.SetHint(null);
					_mapUi.SetContext(null, null);
				}
			}
		}

		private void OpenWorkbenchForId(AtlasId id)
		{
			if (_pinCommands == null || !_pinStore.TryGet(id, out AtlasPin pin) || pin.Deleted)
			{
				return;
			}
			if (!AtlasAccessAllowed(out string denial))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, denial, 0, (Sprite)null);
				}
			}
			else
			{
				_workbenchPanel.UiScale = _settings.UiScale.Value;
				_mapUi.OpenExclusive(_workbenchToken, delegate
				{
					_workbenchPanel.OpenForManaged(pin, _pinCommands.Operations, ResyncPins);
				});
			}
		}

		private void UpgradeAndEdit(PinData pin)
		{
			if (_pinCommands == null)
			{
				return;
			}
			if (!AtlasAccessAllowed(out string denial))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, denial, 0, (Sprite)null);
				}
			}
			else
			{
				if (!_pinAdapter.ContainsPin(pin) || !_pinAdapter.IsAdoptableVanilla(pin))
				{
					return;
				}
				AtlasPin managed = _pinAdapter.Adopt(_pinStore, pin);
				if (managed != null)
				{
					_workbenchPanel.UiScale = _settings.UiScale.Value;
					_mapUi.OpenExclusive(_workbenchToken, delegate
					{
						_workbenchPanel.OpenForManaged(managed, _pinCommands.Operations, ResyncPins);
					});
				}
			}
		}

		private void HandlePaletteBirth(PinData born)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected I4, but got Unknown
			string committedName = born.m_name ?? "";
			bool num = _pinAdapter.ContainsPin(born);
			PinData val = (num ? null : _pinAdapter.TryFindAdoptableAt(born.m_pos, committedName));
			PaletteBirthResolution.Action action = PaletteBirthResolution.Decide(num, num && _pinAdapter.IsAdoptableVanilla(born), val != null, committedName);
			AtlasPin atlasPin;
			switch (action)
			{
			case PaletteBirthResolution.Action.AdoptBorn:
				atlasPin = _pinAdapter.Adopt(_pinStore, born);
				break;
			case PaletteBirthResolution.Action.AdoptReplacement:
				atlasPin = _pinAdapter.Adopt(_pinStore, val);
				_log.LogInfo((object)"Palette birth: the naming close replaced the pin object; adopted the replacement at the same spot (RC12 blocker 5).");
				break;
			case PaletteBirthResolution.Action.RecreateManaged:
			{
				RoadPoint position = new RoadPoint(born.m_pos.x, born.m_pos.y, born.m_pos.z);
				int bornType = (int)born.m_type;
				atlasPin = _pinStore.Create(delegate(AtlasPin pin)
				{
					pin.Name = committedName;
					pin.IconId = IconRegistry.FromVanillaType(bornType);
					pin.Source = AtlasPinSource.Managed;
					pin.Position = position;
				});
				_log.LogInfo((object)"Palette birth: the named pin's rendering vanished at naming close; recreated it as a managed marker (RC12 blocker 5).");
				break;
			}
			case PaletteBirthResolution.Action.DropForeign:
				_log.LogInfo((object)"Palette birth: the named pin is not adoptable (foreign or already tracked); left untouched.");
				return;
			default:
				if (_settings.DebugLogging.Value)
				{
					_log.LogInfo((object)"Palette birth: naming was cancelled; nothing created.");
				}
				return;
			}
			if (atlasPin == null)
			{
				return;
			}
			string iconId = _birthTracker.IconId;
			string category = _birthTracker.Category;
			_pinStore.Mutate(atlasPin.Id, delegate(AtlasPin pin)
			{
				if (iconId.Length > 0)
				{
					pin.IconId = iconId;
				}
				pin.Category = category;
				pin.Source = AtlasPinSource.Managed;
			});
			_palettePanel.NoteUsed(iconId);
			_displayController.MarkStickyVisible(atlasPin.Id);
			ResyncPins();
			if (_settings.DebugLogging.Value)
			{
				_log.LogInfo((object)$"Palette marker born managed: {atlasPin.Id} icon {iconId} category \"{category}\".");
			}
		}

		private void EnforceVanillaPaletteVisibility()
		{
			bool flag = !_settings.Enabled.Value || !_settings.EnhancedPinPalette.Value || _settings.ShowVanillaPinPalette.Value || _settings.ShowVanillaMapControls.Value || _compatibility.PinManagerPresent || _palettePanel.HasFailed || _mapUi.HasFailed;
			foreach (GameObject placeableIconButton in MinimapReflection.GetPlaceableIconButtons())
			{
				if ((Object)(object)placeableIconButton != (Object)null && placeableIconButton.activeSelf != flag)
				{
					placeableIconButton.SetActive(flag);
				}
			}
			bool flag2 = !_settings.Enabled.Value || _settings.ShowVanillaMapControls.Value || _compatibility.PinManagerPresent || _systemMarkersPanel.HasFailed || _drawerPanel.HasFailed || _mapUi.HasFailed;
			foreach (GameObject systemFilterButton in MinimapReflection.GetSystemFilterButtons())
			{
				if ((Object)(object)systemFilterButton != (Object)null && systemFilterButton.activeSelf != flag2)
				{
					systemFilterButton.SetActive(flag2);
				}
			}
			GameObject val = null;
			try
			{
				val = (((Object)(object)Minimap.instance != (Object)null && (Object)(object)Minimap.instance.m_publicPosition != (Object)null) ? ((Component)Minimap.instance.m_publicPosition).gameObject : null);
				if ((Object)(object)val != (Object)null && val.activeSelf != flag2)
				{
					val.SetActive(flag2);
				}
			}
			catch
			{
			}
			if (MinimapReflection.TryGetVanillaRailContainers(out GameObject placeablesContainer, out GameObject filtersContainer, out bool sharedContainer, out string diagnostics))
			{
				if (sharedContainer)
				{
					SetRailContainerActive(placeablesContainer, flag || flag2);
				}
				else
				{
					if ((Object)(object)placeablesContainer != (Object)null)
					{
						SetRailContainerActive(placeablesContainer, flag);
					}
					if ((Object)(object)filtersContainer != (Object)null)
					{
						SetRailContainerActive(filtersContainer, flag2);
					}
				}
			}
			if (!string.Equals(diagnostics, _lastRailDiagnostics, StringComparison.Ordinal))
			{
				_lastRailDiagnostics = diagnostics;
				_log.LogInfo((object)("Vanilla rail chrome: " + diagnostics + "."));
			}
			if (OrphanChromeRule.MustRestore(flag || flag2))
			{
				_chromeSweep.RestoreAll();
			}
			else
			{
				List<GameObject> list = new List<GameObject> { placeablesContainer, filtersContainer, val };
				foreach (GameObject placeableIconButton2 in MinimapReflection.GetPlaceableIconButtons())
				{
					list.Add(placeableIconButton2);
				}
				foreach (GameObject systemFilterButton2 in MinimapReflection.GetSystemFilterButtons())
				{
					list.Add(systemFilterButton2);
				}
				_chromeSweep.Sweep(list);
			}
			if (!string.Equals(_chromeSweep.LastDiagnostics, _lastChromeSweepDiagnostics, StringComparison.Ordinal))
			{
				_lastChromeSweepDiagnostics = _chromeSweep.LastDiagnostics;
				if (_lastChromeSweepDiagnostics.Length > 0)
				{
					_log.LogInfo((object)("Vanilla chrome sweep: " + _lastChromeSweepDiagnostics + "."));
				}
			}
		}

		private static void SetRailContainerActive(GameObject container, bool visible)
		{
			if (container.activeSelf != visible)
			{
				container.SetActive(visible);
			}
		}

		private void RestoreVanillaPalette()
		{
			try
			{
				_chromeSweep.RestoreAll();
				if (MinimapReflection.TryGetVanillaRailContainers(out GameObject placeablesContainer, out GameObject filtersContainer, out bool _, out string _))
				{
					if ((Object)(object)placeablesContainer != (Object)null && !placeablesContainer.activeSelf)
					{
						placeablesContainer.SetActive(true);
					}
					if ((Object)(object)filtersContainer != (Object)null && !filtersContainer.activeSelf)
					{
						filtersContainer.SetActive(true);
					}
				}
				foreach (GameObject placeableIconButton in MinimapReflection.GetPlaceableIconButtons())
				{
					if ((Object)(object)placeableIconButton != (Object)null && !placeableIconButton.activeSelf)
					{
						placeableIconButton.SetActive(true);
					}
				}
				foreach (GameObject systemFilterButton in MinimapReflection.GetSystemFilterButtons())
				{
					if ((Object)(object)systemFilterButton != (Object)null && !systemFilterButton.activeSelf)
					{
						systemFilterButton.SetActive(true);
					}
				}
				if ((Object)(object)Minimap.instance != (Object)null && (Object)(object)Minimap.instance.m_publicPosition != (Object)null && !((Component)Minimap.instance.m_publicPosition).gameObject.activeSelf)
				{
					((Component)Minimap.instance.m_publicPosition).gameObject.SetActive(true);
				}
			}
			catch
			{
			}
		}

		private void OpenWorkbenchAtCursor()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!MinimapReflection.TryScreenToWorldPoint(Input.mousePosition, out var worldPosition))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer == null)
				{
					return;
				}
				worldPosition = ((Component)localPlayer).transform.position;
			}
			OpenWorkbenchNear(worldPosition);
		}

		private bool AtlasAccessAllowed(out string denial)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			denial = "";
			try
			{
				if ((Object)(object)ZoneSystem.instance == (Object)null || !ZoneSystem.instance.GetGlobalKey("nomap"))
				{
					return true;
				}
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null && SurveyScanner.AnyInstanceNear("piece_maptable", ((Component)localPlayer).transform.position, 10f))
				{
					return true;
				}
				denial = AtlasStrings.Get("hud.noMapNeedTable");
				return false;
			}
			catch
			{
				return true;
			}
		}

		private void ShowOnboardingOnce()
		{
			if (_onboardingChecked)
			{
				return;
			}
			_onboardingChecked = true;
			try
			{
				string path = Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", "onboarding-shown.txt");
				if (!File.Exists(path))
				{
					Directory.CreateDirectory(Path.GetDirectoryName(path));
					File.WriteAllText(path, DateTime.UtcNow.ToString("o"));
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)2, AtlasStrings.Get("hud.onboarding"), 0, (Sprite)null);
					}
				}
			}
			catch
			{
			}
		}

		private static bool GamepadDown(string buttonName)
		{
			if (string.IsNullOrEmpty(buttonName))
			{
				return false;
			}
			try
			{
				return ZInput.GetButtonDown(buttonName);
			}
			catch
			{
				return false;
			}
		}

		private void OpenWorkbenchNear(Vector3 world)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			if (_pinCommands == null)
			{
				return;
			}
			if (!AtlasAccessAllowed(out string denial))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, denial, 0, (Sprite)null);
				}
				return;
			}
			_workbenchPanel.UiScale = _settings.UiScale.Value;
			RoadPoint other = new RoadPoint(world.x, world.y, world.z);
			PinOperations operations = _pinCommands.Operations;
			Action resync = ResyncPins;
			AtlasPin atlasPin = null;
			float num = 30f;
			foreach (AtlasPin item in _pinStore.Living)
			{
				float num2 = item.Position.HorizontalDistanceTo(in other);
				if (num2 < num)
				{
					num = num2;
					atlasPin = item;
				}
			}
			if (atlasPin != null)
			{
				AtlasPin captured = atlasPin;
				_mapUi.OpenExclusive(_workbenchToken, delegate
				{
					_workbenchPanel.OpenForManaged(captured, operations, resync);
				});
			}
			else
			{
				if (!_pinAdapter.TryFindNearest(world, 30f, out PinData pin, out float _))
				{
					return;
				}
				if (_pinAdapter.IsAdoptableVanilla(pin) && _compatibility.PinManagerPresent)
				{
					_workbenchPanel.OpenReadOnly("\"" + pin.m_name + "\" — another pin manager is installed; use 'cc_pins adopt' to manage this pin here");
				}
				else if (_pinAdapter.IsAdoptableVanilla(pin))
				{
					PinData captured2 = pin;
					_workbenchPanel.OpenAdoptPrompt(captured2.m_name ?? "", () => _pinAdapter.Adopt(_pinStore, captured2), operations, resync);
				}
				else
				{
					_workbenchPanel.OpenReadOnly($"\"{pin.m_name}\" ({pin.m_type})");
				}
			}
		}

		public void SaveAll()
		{
			_drawerPanel.FlushPosition();
			SaveIfDirty();
			SavePinsSnapshot();
			_savedViewPersistence.Save(_savedViews);
		}

		internal string ExecuteAtlasCommand(string[] args)
		{
			if (!AtlasAccessAllowed(out string denial))
			{
				return denial;
			}
			if (_disposed || !_mapReady)
			{
				return "Concerned Cartographer: no world is loaded yet.";
			}
			string text = ((args.Length == 0) ? "status" : args[0].ToLowerInvariant());
			string text2 = ((args.Length > 1) ? string.Join(" ", args, 1, args.Length - 1) : "");
			switch (text)
			{
			case "status":
				return "Atlas view: query \"" + _displayController.QueryText + "\", pins " + (_displayController.ShowPins ? "on" : "off") + ", cluster " + (_displayController.ClusterEnabled ? "on" : "off") + ", dirt " + (_settings.DrawerShowDirt.Value ? "on" : "off") + ", paved " + (_settings.DrawerShowPaved.Value ? "on" : "off") + ". " + $"{_displayController.VisibleCount} shown, {_displayController.HiddenByFilter} filtered, {_displayController.ClusterCount} clusters.";
			case "query":
				_displayController.SetQuery(text2);
				ReapplyDisplay();
				return $"Filter applied: \"{text2}\" — {_displayController.VisibleCount} shown, {_displayController.HiddenByFilter} filtered. Filters are display-only; 'cc_atlas clear' restores everything.";
			case "clear":
				_displayController.SetQuery("");
				ReapplyDisplay();
				return "Filter cleared; all pins shown.";
			case "paved":
			case "dirt":
			case "pins":
			case "cluster":
			{
				if (!TryParseOnOff(text2, out var enabled))
				{
					return "Usage: cc_atlas " + text + " on|off";
				}
				ApplyToggle(text, enabled);
				return text + " " + (enabled ? "on" : "off") + ".";
			}
			case "view":
				return HandleViewCommand(text2);
			case "compat":
				return _compatibility.Report();
			case "backup":
			{
				long? worldUid = _worldUid;
				if (worldUid.HasValue)
				{
					long valueOrDefault = worldUid.GetValueOrDefault();
					return "Backed up to " + _backupTools.Backup(valueOrDefault);
				}
				return "No world loaded.";
			}
			case "backups":
			{
				long? worldUid = _worldUid;
				if (worldUid.HasValue)
				{
					long valueOrDefault3 = worldUid.GetValueOrDefault();
					List<string> list = _backupTools.ListBackups(valueOrDefault3);
					if (list.Count == 0)
					{
						return "No backups yet. 'cc_atlas backup' creates one; exports/imports use the same folders.";
					}
					StringBuilder stringBuilder2 = new StringBuilder($"{list.Count} backup(s), newest first:");
					for (int i = 0; i < list.Count && i < 10; i++)
					{
						stringBuilder2.Append($"\n  {i + 1}. {Path.GetFileName(list[i])}");
					}
					stringBuilder2.Append("\n'cc_atlas restore <n>' restores one (takes a safety backup first).");
					return stringBuilder2.ToString();
				}
				return "No world loaded.";
			}
			case "restore":
			{
				long? worldUid = _worldUid;
				if (worldUid.HasValue)
				{
					long valueOrDefault4 = worldUid.GetValueOrDefault();
					List<string> list2 = _backupTools.ListBackups(valueOrDefault4);
					if (!int.TryParse(text2.Trim(), out var result) || result < 1 || result > list2.Count)
					{
						return "Usage: cc_atlas restore <n>  (see 'cc_atlas backups')";
					}
					return _backupTools.Restore(valueOrDefault4, list2[result - 1]);
				}
				return "No world loaded.";
			}
			case "support":
			{
				long? worldUid = _worldUid;
				if (worldUid.HasValue)
				{
					long valueOrDefault2 = worldUid.GetValueOrDefault();
					string text3 = _backupTools.WriteSupportReport(valueOrDefault2, "0.10.0", $"enabled={_settings.Enabled.Value}, capture={_settings.CaptureConstructionActions.Value}, " + $"reconcile={_settings.ReconcileTerrainChanges.Value}, " + $"survey={_settings.SurveyRulesEnabled.Value}, cluster={_settings.DrawerCluster.Value}, " + $"contrast={_settings.HighContrast.Value}, uiScale={_settings.UiScale.Value}");
					return "Sanitized support report (no positions/names/notes/world ids/paths) written to " + text3;
				}
				return "No world loaded.";
			}
			case "views":
			{
				StringBuilder stringBuilder = new StringBuilder("Saved views:");
				if (_savedViews.Views.Count == 0)
				{
					return "Saved views: none. 'cc_atlas view save <name>' captures the current filter/layer state.";
				}
				foreach (SavedView view in _savedViews.Views)
				{
					stringBuilder.Append("\n  \"" + view.Name + "\" — query \"" + view.Query + "\"");
				}
				return stringBuilder.ToString();
			}
			default:
				return "Usage: cc_atlas [status|query <text>|clear|pins on/off|cluster on/off|dirt on/off|paved on/off|view save/apply/del <name>|views]";
			}
		}

		internal string ExecuteSurveyCommand(string[] args)
		{
			if (!AtlasAccessAllowed(out string denial))
			{
				return denial;
			}
			if (_disposed || !_mapReady)
			{
				return "Concerned Cartographer: no world is loaded yet.";
			}
			string text = ((args.Length == 0) ? "status" : args[0].ToLowerInvariant());
			string text2 = ((args.Length > 1) ? args[1].ToLowerInvariant() : "");
			string text3 = ((args.Length > 1) ? args[1] : "");
			IReadOnlyList<SurveyEngine.Observation> observations = _surveyEngine.Observations;
			switch (text)
			{
			case "status":
				return "Survey: " + (_settings.SurveyRulesEnabled.Value ? "ENABLED" : "disabled (Survey/SurveyRulesEnabled)") + ", " + $"{_surveyEngine.Rules.Rules.Count} rule(s), {_surveyEngine.Rules.Blacklist.Count} blacklist pattern(s), " + $"{observations.Count} pending observation(s). Rules file: {SurveyRulePersistence.RulePath}";
			case "list":
			{
				if (observations.Count == 0)
				{
					return "No pending observations.";
				}
				StringBuilder stringBuilder = new StringBuilder($"{observations.Count} observation(s):");
				for (int i = 0; i < observations.Count && i < 15; i++)
				{
					SurveyEngine.Observation observation = observations[i];
					stringBuilder.Append($"\n  {i + 1}. {observation.SuggestedName} [{observation.Category}] at ({observation.Position.X:0}, {observation.Position.Z:0})");
				}
				if (observations.Count > 15)
				{
					stringBuilder.Append($"\n  ... and {observations.Count - 15} more.");
				}
				stringBuilder.Append("\ncc_survey accept <n|all> / reject <n|all>");
				return stringBuilder.ToString();
			}
			case "accept":
			{
				if (text2 == "all")
				{
					int num3 = _surveyEngine.AcceptAll(_pinStore, delegate(AtlasPin atlasPin)
					{
						_displayController.MarkStickyVisible(atlasPin.Id);
					});
					ResyncPins();
					return $"Accepted {num3} observation(s) as markers.";
				}
				Guid? guid = null;
				int result3;
				if (text3.StartsWith("id:", StringComparison.OrdinalIgnoreCase) && Guid.TryParse(text3.Substring(3), out var result2))
				{
					guid = result2;
				}
				else if (int.TryParse(text2, out result3) && result3 >= 1 && result3 <= observations.Count)
				{
					guid = observations[result3 - 1].Id;
				}
				if (guid.HasValue)
				{
					Guid valueOrDefault = guid.GetValueOrDefault();
					if (!_surveyEngine.Accept(valueOrDefault, _pinStore, out AtlasPin created))
					{
						return "That observation is no longer pending — the list just updated.";
					}
					if (created != null)
					{
						_displayController.MarkStickyVisible(created.Id);
					}
					ResyncPins();
					return "Accepted \"" + created?.Name + "\" as a marker.";
				}
				return "Usage: cc_survey accept <n|all>";
			}
			case "reject":
			{
				if (text2 == "all")
				{
					int num6 = _surveyEngine.RejectAll(DateTime.UtcNow);
					SaveRejectedIfDirty();
					return $"Rejected {num6} observation(s); they moved to the Rejected list.";
				}
				Guid? guid2 = null;
				int result7;
				if (text3.StartsWith("id:", StringComparison.OrdinalIgnoreCase) && Guid.TryParse(text3.Substring(3), out var result6))
				{
					guid2 = result6;
				}
				else if (int.TryParse(text2, out result7) && result7 >= 1 && result7 <= observations.Count)
				{
					guid2 = observations[result7 - 1].Id;
				}
				if (guid2.HasValue)
				{
					Guid valueOrDefault2 = guid2.GetValueOrDefault();
					if (!_surveyEngine.Reject(valueOrDefault2, DateTime.UtcNow))
					{
						return "That observation is no longer pending — the list just updated.";
					}
					SaveRejectedIfDirty();
					return "Rejected; it moved to the Rejected list.";
				}
				return "Usage: cc_survey reject <n|all>";
			}
			case "rejected":
			{
				if (_surveyEngine.Rejected.Count == 0)
				{
					return "The Rejected list is empty.";
				}
				StringBuilder stringBuilder2 = new StringBuilder($"{_surveyEngine.Rejected.Count} rejected:");
				for (int num4 = 0; num4 < _surveyEngine.Rejected.Count && num4 < 15; num4++)
				{
					SurveyEngine.RejectedObservation rejectedObservation = _surveyEngine.Rejected[num4];
					stringBuilder2.Append($"\n  {num4 + 1}. {rejectedObservation.SuggestedName} [{rejectedObservation.Category}] at ({rejectedObservation.Position.X:0}, {rejectedObservation.Position.Z:0})");
				}
				if (_surveyEngine.Rejected.Count > 15)
				{
					stringBuilder2.Append($"\n  ... and {_surveyEngine.Rejected.Count - 15} more.");
				}
				return stringBuilder2.ToString();
			}
			case "restore":
			{
				if (text2 == "all")
				{
					int num = _surveyEngine.RestoreAllRejected(DateTime.UtcNow);
					SaveRejectedIfDirty();
					return $"Restored {num} rejected observation(s) to pending review.";
				}
				int num2 = -1;
				int result;
				if (text3.StartsWith("key:", StringComparison.OrdinalIgnoreCase))
				{
					num2 = _surveyEngine.FindRejectedIndex(text3.Substring(4));
					if (num2 < 0)
					{
						return "That rejected entry is no longer listed — the list just updated.";
					}
				}
				else if (int.TryParse(text2, out result))
				{
					num2 = result - 1;
				}
				if (num2 >= 0 && _surveyEngine.RestoreRejected(num2, DateTime.UtcNow))
				{
					SaveRejectedIfDirty();
					return "Restored the rejected entry to pending review.";
				}
				return "Usage: cc_survey restore <n|all>";
			}
			case "acceptrejected":
			{
				int num5 = -1;
				int result5;
				if (text3.StartsWith("key:", StringComparison.OrdinalIgnoreCase))
				{
					num5 = _surveyEngine.FindRejectedIndex(text3.Substring(4));
					if (num5 < 0)
					{
						return "That rejected entry is no longer listed — the list just updated.";
					}
				}
				else if (int.TryParse(text2, out result5))
				{
					num5 = result5 - 1;
				}
				if (num5 >= 0 && _surveyEngine.AcceptRejected(num5, _pinStore, out AtlasPin created2))
				{
					if (created2 != null)
					{
						_displayController.MarkStickyVisible(created2.Id);
					}
					ResyncPins();
					SaveRejectedIfDirty();
					return "Accepted \"" + created2?.Name + "\" as a marker.";
				}
				return "Usage: cc_survey acceptrejected <n>";
			}
			case "rules":
			{
				if (_surveyEngine.Rules.Rules.Count == 0)
				{
					return "No survey rules. Add one from the Survey panel's Rules view.";
				}
				StringBuilder stringBuilder3 = new StringBuilder($"{_surveyEngine.Rules.Rules.Count} rule(s):");
				for (int num7 = 0; num7 < _surveyEngine.Rules.Rules.Count; num7++)
				{
					SurveyRule surveyRule2 = _surveyEngine.Rules.Rules[num7];
					stringBuilder3.Append(string.Format("\n  {0}. [{1}] {2} → {3} ({4})", num7 + 1, surveyRule2.Enabled ? "on " : "OFF", surveyRule2.Pattern, surveyRule2.Category, surveyRule2.IconId));
				}
				return stringBuilder3.ToString();
			}
			case "ruleon":
			case "ruleoff":
			{
				if (int.TryParse(text2, out var result4))
				{
					SurveyRule surveyRule = _surveyEngine.Rules.SetRuleEnabled(result4 - 1, text == "ruleon");
					if (surveyRule != null)
					{
						_surveyRulePersistence.Save(_surveyEngine.Rules);
						return "Rule \"" + surveyRule.Pattern + "\" is now " + (surveyRule.Enabled ? "enabled" : "disabled") + ".";
					}
				}
				return "Usage: cc_survey ruleon <n> / ruleoff <n>";
			}
			case "ruledel":
			{
				if (int.TryParse(text2, out var result8))
				{
					SurveyRule surveyRule3 = _surveyEngine.Rules.RemoveRuleAt(result8 - 1);
					if (surveyRule3 != null)
					{
						_surveyRulePersistence.Save(_surveyEngine.Rules);
						return "Removed rule \"" + surveyRule3.Pattern + "\".";
					}
				}
				return "Usage: cc_survey ruledel <n>";
			}
			case "ruleadd":
			{
				string text4 = SurveyRuleSet.Clean(text2);
				if (text4.Length == 0 || text4 == "*")
				{
					return "Usage: cc_survey ruleadd <prefab-pattern> ('bush*' matches prefixes)";
				}
				string text5 = ((args.Length > 2) ? args[2] : "cc:resource");
				string text6 = ((args.Length > 3) ? string.Join(" ", args, 3, args.Length - 3) : "Resources");
				_surveyEngine.Rules.AddRule(new SurveyRule(text4, text5, text6, 30f, 120f));
				_surveyRulePersistence.Save(_surveyEngine.Rules);
				return "Added rule \"" + text4 + "\" → " + text6 + " (" + text5 + ").";
			}
			case "reload":
				_surveyEngine.Rules = _surveyRulePersistence.LoadOrCreate();
				return $"Reloaded {_surveyEngine.Rules.Rules.Count} rule(s) and {_surveyEngine.Rules.Blacklist.Count} blacklist pattern(s).";
			case "path":
				return SurveyRulePersistence.RulePath + " (the file is the shareable import/export format)";
			default:
				return "Usage: cc_survey [status|list|accept <n|all>|reject <n|all>|rejected|restore <n|all>|acceptrejected <n>|rules|ruleon/ruleoff/ruledel <n>|ruleadd <pattern> [icon] [category]|reload|path]";
			}
		}

		private void SaveRejectedIfDirty()
		{
			if (!_surveyEngine.RejectedDirty)
			{
				return;
			}
			long? worldUid = _worldUid;
			if (worldUid.HasValue)
			{
				long valueOrDefault = worldUid.GetValueOrDefault();
				if (_surveyRejectedPersistence.Save(valueOrDefault, _surveyEngine.Rejected))
				{
					_surveyEngine.MarkRejectedClean();
				}
			}
		}

		private string HandleViewCommand(string remainder)
		{
			int num = remainder.IndexOf(' ');
			string text = ((num < 0) ? remainder : remainder.Substring(0, num)).ToLowerInvariant();
			string text2 = ((num < 0) ? "" : remainder.Substring(num + 1).Trim());
			if (text2.Length == 0)
			{
				return "Usage: cc_atlas view save|apply|del <name>";
			}
			switch (text)
			{
			case "save":
				_drawerPanel.ViewSaved?.Invoke(text2);
				return "View \"" + text2 + "\" saved with the current filter and layer state.";
			case "apply":
				if (!ApplySavedView(text2))
				{
					return "No view named \"" + text2 + "\".";
				}
				return "View \"" + text2 + "\" applied.";
			case "del":
			{
				bool num2 = _savedViews.Remove(text2);
				_savedViewPersistence.Save(_savedViews);
				if (!num2)
				{
					return "No view named \"" + text2 + "\".";
				}
				return "View \"" + text2 + "\" deleted.";
			}
			default:
				return "Usage: cc_atlas view save|apply|del <name>";
			}
		}

		private void ApplyToggle(string which, bool enabled)
		{
			switch (which)
			{
			case "pins":
				_settings.DrawerShowPins.Value = enabled;
				_displayController.ShowPins = enabled;
				ReapplyDisplay();
				break;
			case "cluster":
				_settings.DrawerCluster.Value = enabled;
				_displayController.ClusterEnabled = enabled;
				ReapplyDisplay();
				break;
			case "dirt":
				_settings.DrawerShowDirt.Value = enabled;
				_renderer.SetOverlayEnabled(RoadKind.Dirt, enabled);
				break;
			case "paved":
				_settings.DrawerShowPaved.Value = enabled;
				_renderer.SetOverlayEnabled(RoadKind.Paved, enabled);
				break;
			}
		}

		private static bool TryParseOnOff(string text, out bool enabled)
		{
			switch (text.Trim().ToLowerInvariant())
			{
			case "on":
			case "true":
			case "1":
				enabled = true;
				return true;
			case "off":
			case "false":
			case "0":
				enabled = false;
				return true;
			default:
				enabled = false;
				return false;
			}
		}

		private void SavePinsSnapshot()
		{
			long? worldUid = _worldUid;
			if (worldUid.HasValue)
			{
				long valueOrDefault = worldUid.GetValueOrDefault();
				_pinPersistence.Save(valueOrDefault, _pinStore);
				_routePersistence.Save(valueOrDefault, _routeStore);
			}
		}

		internal string ExecuteSyncCommand(string[] args)
		{
			if (!AtlasAccessAllowed(out string denial))
			{
				return denial;
			}
			if (_disposed || !_mapReady)
			{
				return "Concerned Cartographer: no world is loaded yet.";
			}
			string text = ((args.Length == 0) ? "status" : args[0].ToLowerInvariant());
			string text2 = ((args.Length > 1) ? string.Join(" ", args, 1, args.Length - 1).Trim() : "");
			switch (text)
			{
			case "status":
				var (list3, list4) = SyncPlanner.CollectShared(_pinStore, _routeStore);
				return $"Sync: sharing {list3.Count} pin(s) and {list4.Count} route(s) " + $"(scope table/server, tombstones included). Inbox: {_syncInbox.Envelopes.Count} pending share(s). " + "Set a pin/route scope with 'cc_pins scope table' or 'cc_routes ...' to share it; 'cc_sync share' broadcasts.";
			case "share":
			{
				var (list, list2) = SyncPlanner.CollectShared(_pinStore, _routeStore);
				if (list.Count == 0 && list2.Count == 0)
				{
					return "Nothing is scoped for sharing yet. 'cc_pins scope table' near a pin shares it.";
				}
				Player localPlayer = Player.m_localPlayer;
				string authorName = ((localPlayer != null) ? localPlayer.GetPlayerName() : null) ?? "";
				_syncTransport.Share(_authorId, authorName, list, list2, out string message);
				_log.LogInfo((object)("Sync share: " + message));
				return message;
			}
			case "inbox":
			{
				if (_syncInbox.Envelopes.Count == 0)
				{
					return "Sync inbox: empty.";
				}
				StringBuilder stringBuilder = new StringBuilder("Sync inbox:");
				foreach (SyncInbox.Envelope envelope3 in _syncInbox.Envelopes)
				{
					stringBuilder.Append($"\n  {envelope3.AuthorName}: {envelope3.Pins.Count} pin(s), {envelope3.Routes.Count} route(s) " + $"at {envelope3.ReceivedUtc:HH:mm} UTC — 'cc_sync preview {envelope3.AuthorName}'");
				}
				return stringBuilder.ToString();
			}
			case "preview":
			{
				if (!_syncInbox.TryPeek(text2, out SyncInbox.Envelope envelope2))
				{
					return "No pending share from \"" + text2 + "\". 'cc_sync inbox' lists them.";
				}
				SyncPlan syncPlan2 = SyncPlanner.Plan(_pinStore, _routeStore, envelope2.Pins, envelope2.Routes);
				List<string> list5 = syncPlan2.DeletionNames(10);
				string text4 = ((list5.Count == 0) ? "" : ("\n  Would DELETE: " + string.Join(", ", list5) + ((syncPlan2.TombstonePins.Count + syncPlan2.TombstoneRoutes.Count > list5.Count) ? $" (+{syncPlan2.TombstonePins.Count + syncPlan2.TombstoneRoutes.Count - list5.Count} more)" : "")));
				return "Share from " + envelope2.AuthorName + ": " + syncPlan2.Summary() + "." + text4 + ((syncPlan2.PinConflicts.Count + syncPlan2.RouteConflicts.Count > 0) ? (" Apply with 'cc_sync apply " + envelope2.AuthorName + " mine' (keep local on conflicts) or '... theirs'.") : (" Apply with 'cc_sync apply " + envelope2.AuthorName + "'."));
			}
			case "apply":
			{
				string[] array = text2.Split(new char[1] { ' ' });
				bool flag = array.Length > 1 && string.Equals(array[^1], "theirs", StringComparison.OrdinalIgnoreCase);
				string text3 = ((flag || (array.Length > 1 && string.Equals(array[^1], "mine", StringComparison.OrdinalIgnoreCase))) ? string.Join(" ", array, 0, array.Length - 1) : text2);
				if (!_syncInbox.TryTake(text3, out SyncInbox.Envelope envelope))
				{
					return "No pending share from \"" + text3 + "\".";
				}
				SyncPlan syncPlan = SyncPlanner.Plan(_pinStore, _routeStore, envelope.Pins, envelope.Routes);
				int num = SyncPlanner.Apply(syncPlan, _pinStore, _routeStore, flag);
				ResyncPins();
				_routeRedrawPending = true;
				SavePinsSnapshot();
				_log.LogInfo((object)$"Sync apply: {num} change(s); {syncPlan.Summary()}");
				return $"Applied {num} change(s) from {envelope.AuthorName} " + "(" + (flag ? "conflicts took their side" : "conflicts kept your side") + "). " + syncPlan.Summary();
			}
			case "clear":
				_syncInbox.Clear();
				return "Sync inbox cleared.";
			default:
				return "Usage: cc_sync [status|share|inbox|preview <author>|apply <author> [mine|theirs]|clear]";
			}
		}

		internal string ExecuteRouteCommand(string[] args)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (!AtlasAccessAllowed(out string denial))
			{
				return denial;
			}
			if (_disposed || !_mapReady || _routeCommands == null)
			{
				return "Concerned Cartographer: no world is loaded yet.";
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer == null)
			{
				return "Concerned Cartographer: no local player.";
			}
			return _routeCommands.Execute(args, ((Component)localPlayer).transform.position);
		}

		private void HandleTerrainOperation(CapturedTerrainOperation operation)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed || !_settings.Enabled.Value || !_mapReady || _pipeline == null)
			{
				return;
			}
			long? worldUid = _worldUid;
			if (!worldUid.HasValue)
			{
				return;
			}
			_rateLimited.Info("terrain-action-" + operation.Category, $"Terrain action classified: {operation.ActionDescription} r={operation.RadiusMeters:0.#}m.");
			RoadPoint center = new RoadPoint(operation.Position.x, operation.Position.y, operation.Position.z);
			float radiusMeters = operation.RadiusMeters + 1f;
			if (!operation.RoadKind.HasValue)
			{
				int num = _terrainIntent.AddExclusion(center.X, center.Z, radiusMeters);
				if (num > 0 && _settings.DebugLogging.Value)
				{
					_rateLimited.Info("terrain-intent-add", $"Terraforming r={operation.RadiusMeters:0.#}m: " + $"{num} cell(s) marked not-road ({_terrainIntent.Count} total).");
				}
			}
			else
			{
				_terrainIntent.ClearExclusion(center.X, center.Z, radiusMeters);
			}
			RoadKind? roadKind;
			if (_settings.ReconcileTerrainChanges.Value)
			{
				int num2 = 0;
				roadKind = operation.RoadKind;
				if (roadKind.HasValue)
				{
					RoadKind valueOrDefault = roadKind.GetValueOrDefault();
					RoadKind kind = ((valueOrDefault != RoadKind.Dirt) ? RoadKind.Dirt : RoadKind.Paved);
					num2 = RemoveCoverageWithBackup(kind, center, operation.RadiusMeters);
				}
				else
				{
					num2 = RemoveCoverageWithBackup(RoadKind.Dirt, center, operation.RadiusMeters) + RemoveCoverageWithBackup(RoadKind.Paved, center, operation.RadiusMeters);
				}
				if (num2 > 0)
				{
					_redrawPending = true;
					_log.LogInfo((object)("Reconciled a terrain change (" + operation.ActionDescription + ") " + $"r={operation.RadiusMeters:0.#}m: removed {num2} road point(s)."));
				}
			}
			roadKind = operation.RoadKind;
			if (roadKind.HasValue)
			{
				RoadKind valueOrDefault2 = roadKind.GetValueOrDefault();
				if (_settings.CaptureConstructionActions.Value)
				{
					ObserveAndDraw(rules: new RoadSamplingRules(_settings.MinimumPointSpacingMeters.Value, _settings.MaximumStrokeGapMeters.Value, _settings.DuplicateSuppressionMeters.Value), source: RoadObservationSource.Construction, kind: valueOrDefault2, position: operation.Position, debugKey: "construction-observed");
				}
			}
		}

		private int RemoveCoverageWithBackup(RoadKind kind, RoadPoint center, float radiusMeters)
		{
			_persistence.BackupBeforeReconciliation(_worldUid.Value);
			return _atlas.RemoveCoverage(kind, center, radiusMeters);
		}

		private void ObserveAndDraw(RoadObservationSource source, RoadKind kind, Vector3 position, RoadSamplingRules rules, string debugKey)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!_disposed && _settings.Enabled.Value && _mapReady && _pipeline != null)
			{
				RoadObservation observation = new RoadObservation(source, kind, new RoadPoint(position.x, position.y, position.z));
				int pointCount = _atlas.PointCount;
				if (_pipeline.Observe(in observation, rules, out var segment))
				{
					_renderer.DrawSegment(segment);
				}
				else if (_atlas.PointCount > pointCount)
				{
					_renderer.DrawPoint(kind, observation.Position);
				}
				if (_settings.DebugLogging.Value)
				{
					_rateLimited.Info(debugKey, $"Observed {observation.Source}/{observation.Kind}.");
				}
			}
		}

		internal string ExecuteRoadCommand(string[] args)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			if (!AtlasAccessAllowed(out string denial))
			{
				return denial;
			}
			if (!_disposed && _mapReady && _editor != null)
			{
				long? worldUid = _worldUid;
				if (worldUid.HasValue)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer == null)
					{
						return "Concerned Cartographer: no local player.";
					}
					Vector3 position = ((Component)localPlayer).transform.position;
					RoadPoint position2 = new RoadPoint(position.x, position.y, position.z);
					string text = ((args.Length == 0) ? "status" : args[0].ToLowerInvariant());
					float radius = 10f;
					if (args.Length > 1 && float.TryParse(args[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
					{
						radius = Mathf.Clamp(result, 1f, 100f);
					}
					bool flag;
					string summary;
					switch (text)
					{
					case "status":
					{
						int num3 = 0;
						foreach (RoadStroke stroke in _atlas.Strokes)
						{
							if (stroke.Hidden)
							{
								num3++;
							}
						}
						return $"Atlas: {_atlas.Strokes.Count} road(s), {_atlas.PointCount} point(s), " + $"{num3} hidden, undo depth {_editor.UndoCount}. {_editor.DescribeNearest(position2, radius)}";
					}
					case "delete":
						flag = MutateWithBackup(() => _editor.DeleteNearest(position2, radius, out _lastToolSummary));
						summary = _lastToolSummary;
						break;
					case "kind":
						flag = MutateWithBackup(() => _editor.ReclassifyNearest(position2, radius, out _lastToolSummary));
						summary = _lastToolSummary;
						break;
					case "hide":
						flag = MutateWithBackup(() => _editor.SetHiddenNearest(position2, radius, hidden: true, out _lastToolSummary));
						summary = _lastToolSummary;
						break;
					case "unhide":
						flag = MutateWithBackup(() => _editor.SetHiddenNearest(position2, radius, hidden: false, out _lastToolSummary));
						summary = _lastToolSummary;
						break;
					case "split":
						flag = MutateWithBackup(() => _editor.SplitNearest(position2, radius, out _lastToolSummary));
						summary = _lastToolSummary;
						break;
					case "join":
						flag = MutateWithBackup(() => _editor.JoinNearest(position2, radius, out _lastToolSummary));
						summary = _lastToolSummary;
						break;
					case "rebuild":
					{
						float num = ((args.Length > 1) ? radius : 32f);
						_persistence.BackupBeforeReconciliation(_worldUid.Value);
						int num2 = _atlas.RemoveCoverage(RoadKind.Dirt, position2, num) + _atlas.RemoveCoverage(RoadKind.Paved, position2, num);
						flag = num2 > 0;
						summary = $"Cleared {num2} road point(s) within {num:0.#} m. " + "Roads return only when you Pathen/Pave the ground again ('cc_roads undo' reverts).";
						break;
					}
					case "undo":
						flag = _editor.Undo(out summary);
						break;
					case "align":
						if (args.Length > 1 && string.Equals(args[1], "clear", StringComparison.OrdinalIgnoreCase))
						{
							_renderer.ClearAlignmentProbe();
							_renderer.RedrawAll(_atlas);
							_redrawPending = false;
							return "Alignment markers removed.";
						}
						if (args.Length > 1 && string.Equals(args[1], "live", StringComparison.OrdinalIgnoreCase))
						{
							RoadKind kind;
							bool standingOnRoad = _probe.TryClassify(position, out kind);
							RoadPoint nearest;
							float distanceMeters;
							bool hasNearest = _atlas.TryGetNearestPointOnRoads(position2, 50f, out nearest, out distanceMeters);
							string result2 = LiveAlignmentProbe.BuildReport(position, standingOnRoad, kind, _surveyor?.LatestSample, _pipeline?.LastAccepted, hasNearest, nearest, distanceMeters, _renderer);
							_log.LogInfo((object)"cc_roads align live: diagnostic report written to the console (positions are never logged).");
							return result2;
						}
						return _renderer.RunAlignmentProbe(position, _atlas);
					default:
						return "Usage: cc_roads [status|delete|kind|hide|unhide|split|join|rebuild|undo] [radius].";
					}
					if (flag)
					{
						_redrawPending = true;
						SaveIfDirty();
						_log.LogInfo((object)("Road tool '" + text + "': " + summary));
					}
					return summary;
				}
			}
			return "Concerned Cartographer: no world is loaded yet.";
		}

		private bool MutateWithBackup(Func<bool> operation)
		{
			_persistence.BackupBeforeReconciliation(_worldUid.Value);
			return operation();
		}

		public void SaveIfDirty()
		{
			long? worldUid = _worldUid;
			if (worldUid.HasValue)
			{
				if (_atlas.IsDirty && _persistence.Save(_worldUid.Value, _atlas))
				{
					_atlas.MarkClean();
				}
				if (_terrainIntent.IsDirty && _terrainIntentPersistence.Save(_worldUid.Value, _terrainIntent))
				{
					_terrainIntent.MarkClean();
				}
			}
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_workbenchPanel.Close();
				RestoreVanillaPalette();
				_overlayRelabel.Restore();
				_textFocusBlock.Release();
				_quickPinGate.Disarm();
				MapInputGate.Uninstall();
				PlayerInputGate.Uninstall();
				PinDeletionWatch.Uninstall();
				MapPointerGuard.Clear();
				SaveIfDirty();
				SavePinsSnapshot();
				SaveRejectedIfDirty();
				_pipeline?.EndAllStrokes();
				_constructionCapture.OperationCaptured -= HandleTerrainOperation;
				_constructionCapture.Dispose();
				_disposed = true;
			}
		}

		private void SwitchWorld(long uid)
		{
			if (_worldUid != uid || _surveyor == null)
			{
				SaveRejectedIfDirty();
				SaveIfDirty();
				SavePinsSnapshot();
				_worldUid = uid;
				_atlas = _persistence.Load(uid);
				_terrainIntent = _terrainIntentPersistence.Load(uid);
				_pinStore = _pinPersistence.Load(uid);
				_surveyEngine.ResetSession();
				_surveyEngine.LoadRejected(_surveyRejectedPersistence.Load(uid));
				_pinStore.LocalAuthor = _authorId;
				_pinStore.Changed += _pinPersistence.QueueJournal;
				_pinAdapter.Reset();
				_pinCommands = new PinCommandHandler(_pinStore, new PinOperations(_pinStore), _pinAdapter, _log, ResyncPins);
				_displayController.Reset();
				_routeStore = _routePersistence.Load(uid);
				_routeStore.LocalAuthor = _authorId;
				_routeStore.Changed += _routePersistence.QueueJournal;
				_syncInbox.Clear();
				_routeCommands = new RouteCommandHandler(_routeStore, new RouteOperations(_routeStore), _atlas, _settings, _log, delegate
				{
					_routeRedrawPending = true;
				});
				_pipeline = new RoadObservationPipeline(_atlas, _terrainIntent);
				_editor = new RoadAtlasEditor(_atlas);
				_surveyor = new RoadSurveyor(_settings, _probe, _atlas, _log);
				_redrawPending = false;
				_autosaveElapsed = 0f;
			}
		}
	}
	internal sealed class CartographerSettings
	{
		public ConfigEntry<bool> Enabled { get; }

		public ConfigEntry<bool> CaptureConstructionActions { get; }

		public ConfigEntry<bool> ReconcileTerrainChanges { get; }

		public ConfigEntry<float> SampleIntervalSeconds { get; }

		public ConfigEntry<float> MinimumPointSpacingMeters { get; }

		public ConfigEntry<float> MaximumStrokeGapMeters { get; }

		public ConfigEntry<float> DuplicateSuppressionMeters { get; }

		public ConfigEntry<float> AutosaveIntervalSeconds { get; }

		public ConfigEntry<float> PaintThreshold { get; }

		public ConfigEntry<int> PaintSampleRadius { get; }

		public ConfigEntry<int> LineWidthPixels { get; }

		public ConfigEntry<bool> DebugLogging { get; }

		public ConfigEntry<bool> DrawCalibrationMarkers { get; }

		public ConfigEntry<KeyCode> WorkbenchHotkey { get; }

		public ConfigEntry<KeyCode> DrawerHotkey { get; }

		public ConfigEntry<bool> DrawerShowDirt { get; }

		public ConfigEntry<bool> DrawerShowPaved { get; }

		public ConfigEntry<bool> DrawerShowPins { get; }

		public ConfigEntry<bool> DrawerCluster { get; }

		public ConfigEntry<string> DrawerPanelPosition { get; }

		public ConfigEntry<KeyCode> QuickPinHotkey { get; }

		public ConfigEntry<float> QuickPinDuplicateRadius { get; }

		public ConfigEntry<bool> SurveyRulesEnabled { get; }

		public ConfigEntry<float> SurveyScanIntervalSeconds { get; }

		public ConfigEntry<float> SurveyScanRadius { get; }

		public ConfigEntry<float> SurveyBaseExclusionRadius { get; }

		public ConfigEntry<int> SurveyMaxObservations { get; }

		public ConfigEntry<KeyCode> RouteDrawModifier { get; }

		public ConfigEntry<float> RouteEraseRadius { get; }

		public ConfigEntry<float> RouteSnapRadius { get; }

		public ConfigEntry<float> RouteOnRoadTolerance { get; }

		public ConfigEntry<float> RouteOffRoadSpeed { get; }

		public ConfigEntry<float> RouteOnRoadSpeed { get; }

		public ConfigEntry<float> UiScale { get; }

		public ConfigEntry<bool> HighContrast { get; }

		public ConfigEntry<string> WorkbenchGamepadButton { get; }

		public ConfigEntry<string> DrawerGamepadButton { get; }

		public ConfigEntry<bool> EnhancedPinPalette { get; }

		public ConfigEntry<bool> ShowVanillaPinPalette { get; }

		public ConfigEntry<CrashConsentState> CrashReportingConsent { get; }

		public ConfigEntry<int> AcceptedPrivacyPolicyVersion { get; }

		public ConfigEntry<string> SentryDsn { get; }

		public ConfigEntry<bool> ShowVanillaMapControls { get; }

		public ConfigEntry<bool> HighPrecisionLargeMapRoads { get; }

		private CartographerSettings(ConfigEntry<bool> enabled, ConfigEntry<bool> captureConstructionActions, ConfigEntry<bool> reconcileTerrainChanges, ConfigEntry<float> sampleIntervalSeconds, ConfigEntry<float> minimumPointSpacingMeters, ConfigEntry<float> maximumStrokeGapMeters, ConfigEntry<float> duplicateSuppressionMeters, ConfigEntry<float> autosaveIntervalSeconds, ConfigEntry<float> paintThreshold, ConfigEntry<int> paintSampleRadius, ConfigEntry<int> lineWidthPixels, ConfigEntry<bool> debugLogging, ConfigEntry<bool> drawCalibrationMarkers, ConfigEntry<KeyCode> workbenchHotkey, ConfigEntry<KeyCode> drawerHotkey, ConfigEntry<bool> drawerShowDirt, ConfigEntry<bool> drawerShowPaved, ConfigEntry<bool> drawerShowPins, ConfigEntry<bool> drawerCluster, ConfigEntry<string> drawerPanelPosition, ConfigEntry<KeyCode> quickPinHotkey, ConfigEntry<float> quickPinDuplicateRadius, ConfigEntry<bool> surveyRulesEnabled, ConfigEntry<float> surveyScanIntervalSeconds, ConfigEntry<float> surveyScanRadius, ConfigEntry<float> surveyBaseExclusionRadius, ConfigEntry<int> surveyMaxObservations, ConfigEntry<KeyCode> routeDrawModifier, ConfigEntry<float> routeEraseRadius, ConfigEntry<float> routeSnapRadius, ConfigEntry<float> routeOnRoadTolerance, ConfigEntry<float> routeOffRoadSpeed, ConfigEntry<float> routeOnRoadSpeed, ConfigEntry<float> uiScale, ConfigEntry<bool> highContrast, ConfigEntry<string> workbenchGamepadButton, ConfigEntry<string> drawerGamepadButton, ConfigEntry<bool> enhancedPinPalette, ConfigEntry<bool> showVanillaPinPalette, ConfigEntry<CrashConsentState> crashReportingConsent, ConfigEntry<int> acceptedPrivacyPolicyVersion, ConfigEntry<string> sentryDsn, ConfigEntry<bool> showVanillaMapControls, ConfigEntry<bool> highPrecisionLargeMapRoads)
		{
			Enabled = enabled;
			CaptureConstructionActions = captureConstructionActions;
			ReconcileTerrainChanges = reconcileTerrainChanges;
			SampleIntervalSeconds = sampleIntervalSeconds;
			MinimumPointSpacingMeters = minimumPointSpacingMeters;
			MaximumStrokeGapMeters = maximumStrokeGapMeters;
			DuplicateSuppressionMeters = duplicateSuppressionMeters;
			AutosaveIntervalSeconds = autosaveIntervalSeconds;
			PaintThreshold = paintThreshold;
			PaintSampleRadius = paintSampleRadius;
			LineWidthPixels = lineWidthPixels;
			DebugLogging = debugLogging;
			DrawCalibrationMarkers = drawCalibrationMarkers;
			WorkbenchHotkey = workbenchHotkey;
			DrawerHotkey = drawerHotkey;
			DrawerShowDirt = drawerShowDirt;
			DrawerShowPaved = drawerShowPaved;
			DrawerShowPins = drawerShowPins;
			DrawerCluster = drawerCluster;
			DrawerPanelPosition = drawerPanelPosition;
			QuickPinHotkey = quickPinHotkey;
			QuickPinDuplicateRadius = quickPinDuplicateRadius;
			SurveyRulesEnabled = surveyRulesEnabled;
			SurveyScanIntervalSeconds = surveyScanIntervalSeconds;
			SurveyScanRadius = surveyScanRadius;
			SurveyBaseExclusionRadius = surveyBaseExclusionRadius;
			SurveyMaxObservations = surveyMaxObservations;
			RouteDrawModifier = routeDrawModifier;
			RouteEraseRadius = routeEraseRadius;
			RouteSnapRadius = routeSnapRadius;
			RouteOnRoadTolerance = routeOnRoadTolerance;
			RouteOffRoadSpeed = routeOffRoadSpeed;
			RouteOnRoadSpeed = routeOnRoadSpeed;
			UiScale = uiScale;
			HighContrast = highContrast;
			WorkbenchGamepadButton = workbenchGamepadButton;
			DrawerGamepadButton = drawerGamepadButton;
			EnhancedPinPalette = enhancedPinPalette;
			ShowVanillaPinPalette = showVanillaPinPalette;
			CrashReportingConsent = crashReportingConsent;
			AcceptedPrivacyPolicyVersion = acceptedPrivacyPolicyVersion;
			SentryDsn = sentryDsn;
			ShowVanillaMapControls = showVanillaMapControls;
			HighPrecisionLargeMapRoads = highPrecisionLargeMapRoads;
		}

		public static CartographerSettings Bind(ConfigFile config)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Expected O, but got Unknown
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Expected O, but got Unknown
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Expected O, but got Unknown
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Expected O, but got Unknown
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Expected O, but got Unknown
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Expected O, but got Unknown
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Expected O, but got Unknown
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Expected O, but got Unknown
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Expected O, but got Unknown
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Expected O, but got Unknown
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Expected O, but got Unknown
			return new CartographerSettings(config.Bind<bool>("General", "Enabled", true, "Enable road surveying and map overlays."), config.Bind<bool>("Sources", "CaptureConstructionActions", true, "Record roads from your own successful Pathen (hoe) and Paved (cultivator/stonecutter) actions. This is the ONLY road source: walking existing paint never creates roads."), config.Bind<bool>("Sources", "ReconcileTerrainChanges", true, "When you level, raise, cultivate, reset, or repaint terrain, remove the covered road ink from the atlas so no ghost roads remain."), config.Bind<float>("Survey", "SampleIntervalSeconds", 0.35f, new ConfigDescription("Seconds between diagnostic terrain samples under the player (feeds 'cc_roads align live'; never creates roads).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), Array.Empty<object>())), config.Bind<float>("Survey", "MinimumPointSpacingMeters", 1.5f, new ConfigDescription("Minimum horizontal distance before a new road point is stored.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 20f), Array.Empty<object>())), config.Bind<float>("Survey", "MaximumStrokeGapMeters", 8f, new ConfigDescription("A larger gap starts a new stroke instead of drawing a long connector.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 100f), Array.Empty<object>())), config.Bind<float>("Survey", "DuplicateSuppressionMeters", 2f, new ConfigDescription("Skip samples within this distance of already-recorded road ink of the same kind, so re-walking a road never grows the atlas. 0 disables suppression; values above ~3 may also suppress tight hairpin switchbacks.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>())), config.Bind<float>("Persistence", "AutosaveIntervalSeconds", 15f, new ConfigDescription("Seconds between dirty-atlas autosaves.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 300f), Array.Empty<object>())), config.Bind<float>("Detection", "PaintThreshold", 0.4f, new ConfigDescription("Minimum averaged red/blue paint value used to identify roads.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.95f), Array.Empty<object>())), config.Bind<int>("Detection", "PaintSampleRadius", 1, new ConfigDescription("Terrain paint pixels sampled around the player (0 is a single pixel).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 3), Array.Empty<object>())), config.Bind<int>("Map", "LineWidthPixels", 1, new ConfigDescription("Road line width on the map overlay, in map texels. One texel covers ~11.6 m of world, so widths above 1 make nearby roads merge into blobs.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 6), Array.Empty<object>())), config.Bind<bool>("Diagnostics", "DebugLogging", false, "Write diagnostic road classification messages."), config.Bind<bool>("Diagnostics", "DrawCalibrationMarkers", false, "Draw fixed calibration crosses into the dirt overlay at world origin (magenta), +128m east (yellow), and +128m north (cyan) to verify overlay/map alignment."), config.Bind<KeyCode>("Workbench", "WorkbenchHotkey", (KeyCode)112, "Key that opens the Pin Workbench for the pin under the cursor while the large map is open."), config.Bind<KeyCode>("Drawer", "DrawerHotkey", (KeyCode)108, "Key that toggles the Atlas Drawer (layers, search, saved views) while the large map is open."), config.Bind<bool>("Drawer", "ShowDirtRoads", true, "Show the dirt-road layer."), config.Bind<bool>("Drawer", "ShowPavedRoads", true, "Show the paved-road layer."), config.Bind<bool>("Drawer", "ShowPins", true, "Show managed pins on the map."), config.Bind<bool>("Drawer", "Clustering", true, "Fold crowded pins into cluster markers when zoomed out (display only; never changes stored pins)."), config.Bind<string>("Drawer", "PanelPosition", "", "Internal: the Atlas drawer's last dragged position as \"x,y\" canvas offsets from its right-center anchor. Written when the drawer closes; empty uses the default dock. Restored positions are clamped on-screen, so editing this can never strand the panel."), config.Bind<KeyCode>("Workbench", "QuickPinHotkey", (KeyCode)288, "Key that pins the object you are looking at (set to None to disable). Never pins creatures."), config.Bind<float>("Workbench", "QuickPinDuplicateRadius", 25f, new ConfigDescription("Skip a quick pin when a same-named pin already exists within this many meters (0 disables the check).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 200f), Array.Empty<object>())), config.Bind<bool>("Survey", "SurveyRulesEnabled", false, "Opt-in survey rules: nearby loaded objects matching survey-rules.tsv become reviewable observations (never pins directly)."), config.Bind<float>("Survey", "SurveyScanIntervalSeconds", 10f, new ConfigDescription("Legacy, no effect since v1.0 RC10: the survey scans continuously on a bounded per-frame budget. Kept so existing config files load cleanly.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 60f), Array.Empty<object>())), config.Bind<float>("Survey", "SurveyScanRadius", 40f, new ConfigDescription("Survey scan radius around the player in meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 100f), Array.Empty<object>())), config.Bind<float>("Survey", "SurveyBaseExclusionRadius", 30f, new ConfigDescription("No observations within this distance of a pin categorized/tagged Base (0 disables).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>())), config.Bind<int>("Survey", "SurveyMaxObservations", 200, new ConfigDescription("Hard cap on pending survey observations.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 1000), Array.Empty<object>())), config.Bind<KeyCode>("Routes", "RouteDrawModifier", (KeyCode)304, "Modifier held with LeftClick on the large map for route draw/erase/waypoint modes (avoids vanilla map-drag conflicts)."), config.Bind<float>("Routes", "RouteEraseRadius", 8f, new ConfigDescription("Route erase brush radius in meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 30f), Array.Empty<object>())), config.Bind<float>("Routes", "RouteSnapRadius", 15f, new ConfigDescription("Waypoints snap to roads within this many meters.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 50f), Array.Empty<object>())), config.Bind<float>("Routes", "RouteOnRoadTolerance", 6f, new ConfigDescription("A route counts as on-road when within this distance of recorded road ink.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 15f), Array.Empty<object>())), config.Bind<float>("Routes", "RouteOffRoadSpeed", 2.5f, new ConfigDescription("Off-road travel speed (m/s) for time estimates.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 15f), Array.Empty<object>())), config.Bind<float>("Routes", "RouteOnRoadSpeed", 5f, new ConfigDescription("On-road travel speed (m/s) for time estimates.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 15f), Array.Empty<object>())), config.Bind<float>("Accessibility", "UiScale", 1f, new ConfigDescription("Scale multiplier for Concerned Cartographer panels.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.8f, 1.6f), Array.Empty<object>())), config.Bind<bool>("Accessibility", "HighContrast", false, "High-contrast map ink: near-black dirt, near-white paved, brighter route colors. Kinds stay distinguishable without color (dashed/dotted styles, icons, labels)."), config.Bind<string>("Accessibility", "WorkbenchGamepadButton", "", "ZInput button name that opens the Pin Workbench (e.g. JoyLStick). Empty disables; conflicts are avoided by explicit opt-in."), config.Bind<string>("Accessibility", "DrawerGamepadButton", "", "ZInput button name that toggles the Atlas Drawer. Empty disables."), config.Bind<bool>("Pins", "EnhancedPinPalette", true, "Show the Concerned Cartographer marker palette on the large map. Markers created through it are managed from birth (no upgrade step)."), config.Bind<bool>("Pins", "ShowVanillaPinPalette", false, "Keep Valheim's own five pin-icon buttons visible alongside (or instead of) the enhanced palette. Automatically treated as true when a known conflicting pin manager is installed."), config.Bind<CrashConsentState>("Privacy", "SendCrashReports", CrashConsentState.Unknown, "Send anonymous crash reports when Concerned Cartographer hits an internal error. Unknown = not asked yet (a one-time dialog appears on the first large-map open); nothing is ever sent while Unknown or Disabled. What is and is not collected: PRIVACY.md. No gameplay analytics, ever."), config.Bind<int>("Privacy", "AcceptedPrivacyPolicyVersion", 0, "Internal: the crash-reporting policy version the player answered. Re-prompts only if the collected data categories materially change in a future release."), config.Bind<string>("Privacy", "SentryDsn", "", "Advanced: override the embedded crash-report ingestion DSN (a public event-submission key). Empty uses the built-in value; if both are empty, crash reporting is fully inert. NEVER put a Sentry auth token here."), config.Bind<bool>("Map", "ShowVanillaMapControls", false, "Show Valheim's own right-side map control rail (pin icon selectors, death/boss filter buttons, visible-to-others toggle) alongside the Concerned Cartographer toolbar. Default: the CC toolbar and Atlas System Markers replace it. Automatically treated as true when a known conflicting pin manager is installed."), config.Bind<bool>("Map", "HighPrecisionLargeMapRoads", true, "Render roads on the LARGE map as sub-texel vector geometry that pans/zooms with the map (DEF-v1.0-006), instead of only the 2048-texel texture overlay (which stays for the minimap and as fallback)."));
		}
	}
	internal sealed class CompatibilityRegistry
	{
		public sealed class KnownMod
		{
			public string GuidFragment { get; }

			public string DisplayName { get; }

			public string Behavior { get; }

			public bool Detected { get; set; }

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

			public KnownMod(string guidFragment, string displayName, string behavior)
			{
				GuidFragment = guidFragment;
				DisplayName = displayName;
				Behavior = behavior;
			}
		}

		private readonly List<KnownMod> _knownMods = new List<KnownMod>
		{
			new KnownMod("pinnacle", "Pinnacle", "Pin manager detected: adoption stays fully manual (no adopt prompts from the hotkey on unadopted vanilla pins) so both managers never fight over a pin."),
			new KnownMod("pinassistant", "PinAssistant", "Pin manager detected: adoption stays fully manual; its auto-pins look like vanilla pins and are only touched if you explicitly adopt them."),
			new KnownMod("automappins", "AutoMapPins", "Auto-pinner detected: its pins are unsaved/foreign and are never adopted or edited."),
			new KnownMod("maproutes", "MapRoutes", "Route drawer detected: both route layers coexist (separate overlays); imports are not performed automatically."),
			new KnownMod("bettercartographytable", "Better Cartography Table", "Table mod detected: Concerned Cartographer sharing stays on its own cc_sync channel and never touches table data."),
			new KnownMod("onemap", "OneMap", "Shared-map mod detected: vanilla shared pins carry owner IDs and remain foreign/untouchable to Concerned Cartographer.")
		};

		private bool _evaluated;

		public IReadOnlyList<KnownMod> KnownMods => _knownMods;

		public bool PinManagerPresent { get; private set; }

		public void Evaluate(ManualLogSource log)
		{
			if (_evaluated)
			{
				return;
			}
			_evaluated = true;
			try
			{
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					string text = pluginInfo.Key.ToLowerInvariant();
					foreach (KnownMod knownMod in _knownMods)
					{
						if (!knownMod.Detected && text.Contains(knownMod.GuidFragment))
						{
							knownMod.Detected = true;
							knownMod.DetectedGuid = pluginInfo.Key;
							log.LogInfo((object)("Compatibility: " + knownMod.DisplayName + " detected (" + pluginInfo.Key + "). " + knownMod.Behavior));
						}
					}
				}
				foreach (KnownMod knownMod2 in _knownMods)
				{
					if (knownMod2.Detected && (knownMod2.GuidFragment == "pinnacle" || knownMod2.GuidFragment == "pinassistant"))
					{
						PinManagerPresent = true;
					}
				}
			}
			catch (Exception exception)
			{
				log.LogWarning((object)("Compatibility detection failed harmlessly: " + SafeLogText.Brief(exception)));
			}
		}

		public string Report()
		{
			StringBuilder stringBuilder = new StringBuilder("Compatibility:");
			bool flag = false;
			foreach (KnownMod knownMod in _knownMods)
			{
				if (knownMod.Detected)
				{
					flag = true;
					stringBuilder.Append("\n  " + knownMod.DisplayName + " (" + knownMod.DetectedGuid + ") — " + knownMod.Behavior);
				}
			}
			if (!flag)
			{
				stringBuilder.Append(" no known neighboring mods detected. Baseline interop safety applies regardless.");
			}
			return stringBuilder.ToString();
		}
	}
	internal enum CrashConsentState
	{
		Unknown,
		Enabled,
		Disabled
	}
	internal static class CrashReportingConfig
	{
		public const string EmbeddedSentryDsn = "https://eec0ed91ddb82ee984103b4180573feb@o4511990602989568.ingest.us.sentry.io/4511990681436160";

		public const int ConsentPolicyVersion = 1;

		public const string PrivacyPolicyUrl = "https://github.com/Weakened/ConcernedCatMods/blob/main/PRIVACY.md";
	}
	internal sealed class CrashReportingHub : IDisposable
	{
		private readonly CartographerSettings _settings;

		private readonly ICrashReporter _reporter;

		private readonly CrashReportThrottle _noticeThrottle = new CrashReportThrottle();

		private ManualLogSource? _attachedSource;

		private bool _inHandler;

		private bool _disposed;

		public bool ReportingActive
		{
			get
			{
				if (_settings.CrashReportingConsent.Value == CrashConsentState.Enabled)
				{
					if (_reporter is SentryCrashReporter sentryCrashReporter)
					{
						return sentryCrashReporter.IsOperational;
					}
					return false;
				}
				return false;
			}
		}

		public CrashReportingHub(CartographerSettings settings, CrashReportContext context)
		{
			_settings = settings;
			string text = settings.SentryDsn.Value.Trim();
			if (text.Length == 0)
			{
				text = "https://eec0ed91ddb82ee984103b4180573feb@o4511990602989568.ingest.us.sentry.io/4511990681436160";
			}
			ICrashReporter reporter = new NullCrashReporter();
			if (text.Length > 0)
			{
				SentryCrashReporter sentryCrashReporter = new SentryCrashReporter(text);
				if (sentryCrashReporter.IsOperational)
				{
					reporter = sentryCrashReporter;
				}
				else
				{
					sentryCrashReporter.Dispose();
				}
			}
			_reporter = reporter;
			_reporter.Initialize(context);
			SyncConsent();
			_settings.CrashReportingConsent.SettingChanged += HandleConsentChanged;
		}

		public void Attach(ManualLogSource ownSource)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			_attachedSource = ownSource;
			ownSource.LogEvent += HandleOwnLogEvent;
			Application.logMessageReceived += new LogCallback(HandleUnityLog);
		}

		public void Dispose()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			try
			{
				_settings.CrashReportingConsent.SettingChanged -= HandleConsentChanged;
				if (_attachedSource != null)
				{
					_attachedSource.LogEvent -= HandleOwnLogEvent;
				}
				Application.logMessageReceived -= new LogCallback(HandleUnityLog);
			}
			catch
			{
			}
			_reporter.Dispose();
		}

		private void HandleConsentChanged(object sender, EventArgs e)
		{
			SyncConsent();
		}

		private void SyncConsent()
		{
			try
			{
				_reporter.ConsentGranted = _settings.CrashReportingConsent.Value == CrashConsentState.Enabled;
			}
			catch
			{
			}
		}

		private void HandleOwnLogEvent(object sender, LogEventArgs args)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			if (_disposed || _inHandler || ((int)args.Level != 2 && (int)args.Level != 1))
			{
				return;
			}
			_inHandler = true;
			try
			{
				string text = args.Data?.ToString() ?? "";
				string subsystem = CrashSubsystems.Infer(text);
				_reporter.CaptureFatalSubsystemFailure(subsystem, text);
				NotifyPlayer(subsystem);
			}
			catch
			{
			}
			finally
			{
				_inHandler = false;
			}
		}

		private void HandleUnityLog(string condition, string stackTrace, LogType type)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (_disposed || (int)type != 4)
			{
				return;
			}
			try
			{
				if ((stackTrace != null && stackTrace.Contains("TheConcernedCat.ConcernedCartographer")) || (condition != null && condition.Contains("TheConcernedCat.ConcernedCartographer")))
				{
					_reporter.CaptureException("unhandled", condition + "\n" + stackTrace);
				}
			}
			catch
			{
			}
		}

		private void NotifyPlayer(string subsystem)
		{
			try
			{
				if (_noticeThrottle.ShouldNotify(subsystem))
				{
					string key = (ReportingActive ? "privacy.noticeSent" : "privacy.noticeOff");
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)1, AtlasStrings.Format(key, subsystem), 0, (Sprite)null);
					}
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class PinCommandHandler
	{
		private const float DefaultSelectRadiusMeters = 15f;

		private const float DefaultDuplicateRadiusMeters = 25f;

		private readonly PinStore _store;

		private readonly PinOperations _operations;

		private readonly PinAdapter _adapter;

		private readonly ManualLogSource _log;

		private readonly Action _resyncMap;

		public PinOperations Operations => _operations;

		public PinCommandHandler(PinStore store, PinOperations operations, PinAdapter adapter, ManualLogSource log, Action resyncMap)
		{
			_store = store;
			_operations = operations;
			_adapter = adapter;
			_log = log;
			_resyncMap = resyncMap;
		}

		public string Execute(string[] args, Vector3 playerPosition)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			RoadPoint position = new RoadPoint(playerPosition.x, playerPosition.y, playerPosition.z);
			string text = ((args.Length == 0) ? "status" : args[0].ToLowerInvariant());
			string remainder = ((args.Length > 1) ? string.Join(" ", args, 1, args.Length - 1) : "");
			return text switch
			{
				"status" => Status(position), 
				"list" => ListPins(position, remainder), 
				"adopt" => Adopt(playerPosition, remainder), 
				"adoptall" => AdoptAll(remainder), 
				"create" => Create(position, remainder), 
				"name" => EditNearest(position, "rename to \"" + remainder + "\"", delegate(AtlasPin pin)
				{
					pin.Name = remainder;
				}), 
				"icon" => SetIcon(position, remainder), 
				"icons" => ListIcons(remainder), 
				"category" => EditNearest(position, "category \"" + remainder + "\"", delegate(AtlasPin pin)
				{
					pin.Category = remainder;
				}), 
				"color" => SetColor(position, remainder), 
				"size" => SetSize(position, remainder), 
				"note" => EditNearest(position, "note", delegate(AtlasPin pin)
				{
					pin.Notes = remainder;
				}), 
				"tag+" => EditNearest(position, "tag +" + remainder, delegate(AtlasPin pin)
				{
					string text2 = remainder.Trim();
					if (text2.Length > 0 && !pin.Tags.Contains(text2))
					{
						pin.Tags.Add(text2);
					}
				}), 
				"tag-" => EditNearest(position, "tag -" + remainder, delegate(AtlasPin pin)
				{
					pin.Tags.Remove(remainder.Trim());
				}), 
				"setstatus" => SetStatus(position, remainder), 
				"check" => EditNearest(position, "check", delegate(AtlasPin pin)
				{
					pin.Checked = true;
				}), 
				"uncheck" => EditNearest(position, "uncheck", delegate(AtlasPin pin)
				{
					pin.Checked = false;
				}), 
				"scope" => SetScope(position, remainder), 
				"move" => Move(position), 
				"dup" => Duplicate(position), 
				"archive" => Archive(position, archived: true), 
				"unarchive" => Archive(position, archived: false), 
				"delete" => Delete(position), 
				"restore" => Restore(), 
				"deleted" => ListDeleted(), 
				"dups" => ListDuplicates(remainder), 
				"merge" => Merge(position, remainder), 
				"undo" => UndoRedo(undo: true), 
				"redo" => UndoRedo(undo: false), 
				"coords" => Coordinates(position), 
				_ => "Usage: cc_pins [" + string.Join("|", "status", "list", "adopt", "adoptall", "create", "name", "icon", "icons", "category", "color", "size", "note", "tag+", "tag-", "setstatus", "check", "uncheck", "scope", "move", "dup", "archive", "unarchive", "delete", "restore", "deleted", "dups", "merge", "undo", "redo", "coords") + "] ...", 
			};
		}

		private string Status(RoadPoint position)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (AtlasPin item in _store.All)
			{
				if (item.Deleted)
				{
					num3++;
				}
				else if (item.Archived)
				{
					num2++;
				}
				else
				{
					num++;
				}
			}
			int count = _adapter.ListAdoptable().Count;
			AtlasPin pin;
			float distance;
			string arg = (TryFindNearest(position, 15f, includeArchived: true, out pin, out distance) ? $"Nearest: {Describe(pin)}, {distance:0.#} m away." : "No managed pin nearby.");
			return $"Pins: {num} active, {num2} archived, {num3} deleted, {count} adoptable vanilla. " + $"Undo {_operations.UndoCount}/redo {_operations.RedoCount}. {arg}";
		}

		private string ListPins(RoadPoint position, string filter)
		{
			List<(float, AtlasPin)> list = new List<(float, AtlasPin)>();
			string needle = filter.Trim().ToLowerInvariant();
			foreach (AtlasPin item in _store.Living)
			{
				if (!item.Archived && MatchesFilter(item, needle))
				{
					list.Add((item.Position.HorizontalDistanceTo(in position), item));
				}
			}
			list.Sort(((float Distance, AtlasPin Pin) a, (float Distance, AtlasPin Pin) b) => a.Distance.CompareTo(b.Distance));
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append($"{list.Count} pin(s)");
			int num = Math.Min(list.Count, 15);
			for (int num2 = 0; num2 < num; num2++)
			{
				stringBuilder.Append($"\n  {list[num2].Item1,7:0.#} m  {Describe(list[num2].Item2)}");
			}
			if (list.Count > num)
			{
				stringBuilder.Append($"\n  ... and {list.Count - num} more (refine the filter).");
			}
			return stringBuilder.ToString();
		}

		private string Adopt(Vector3 playerPosition, string radiusText)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			float num = ParseRadius(radiusText, 15f);
			List<PinData> list = _adapter.ListAdoptable();
			PinData val = null;
			float num2 = num;
			foreach (PinData item in list)
			{
				float num3 = Vector2.Distance(new Vector2(item.m_pos.x, item.m_pos.z), new Vector2(playerPosition.x, playerPosition.z));
				if (num3 <= num2)
				{
					num2 = num3;
					val = item;
				}
			}
			if (val == null)
			{
				return $"No adoptable vanilla pin within {num:0.#} m (foreign and system pins are never adopted).";
			}
			AtlasPin atlasPin = _adapter.Adopt(_store, val);
			if (atlasPin == null)
			{
				return "Adoption failed; see the log.";
			}
			_log.LogInfo((object)$"Adopted vanilla pin as {atlasPin.Id}.");
			return "Adopted \"" + atlasPin.Name + "\" (" + atlasPin.IconId + ") as a managed pin. Its position, icon, and checked state are unchanged.";
		}

		private string AdoptAll(string confirm)
		{
			List<PinData> list = _adapter.ListAdoptable();
			if (list.Count == 0)
			{
				return "No adoptable vanilla pins.";
			}
			if (!string.Equals(confirm.Trim(), "confirm", StringComparison.OrdinalIgnoreCase))
			{
				return $"Would adopt {list.Count} vanilla pin(s), preserving position/icon/name/checked state. " + "Run 'cc_pins adoptall confirm' to proceed.";
			}
			int num = 0;
			foreach (PinData item in list)
			{
				if (_adapter.Adopt(_store, item) != null)
				{
					num++;
				}
			}
			_log.LogInfo((object)$"Batch-adopted {num} vanilla pin(s).");
			return $"Adopted {num} vanilla pin(s).";
		}

		private string Create(RoadPoint position, string name)
		{
			AtlasPin atlasPin = _store.Create(delegate(AtlasPin created)
			{
				created.Name = name.Trim();
				created.Position = position;
			});
			_adapter.SyncPin(_store, atlasPin.Id);
			return "Created " + Describe(atlasPin) + " at your position.";
		}

		private string EditNearest(RoadPoint position, string description, Action<AtlasPin> edit)
		{
			if (!TryFindNearest(position, 15f, includeArchived: true, out AtlasPin pin, out float _))
			{
				return NoNearbyPin();
			}
			_operations.BatchEdit(new AtlasId[1] { pin.Id }, edit, description);
			_adapter.SyncPin(_store, pin.Id);
			return "Updated " + Describe(pin) + " (" + description + ").";
		}

		private string SetIcon(RoadPoint position, string iconId)
		{
			string text = iconId.Trim();
			if (!IconRegistry.TryResolve(text, out IconRegistry.IconDefinition definition))
			{
				return "Unknown icon '" + text + "'. Try 'cc_pins icons " + text + "' to search the registry.";
			}
			return EditNearest(position, "icon " + definition.Id, delegate(AtlasPin pin)
			{
				pin.IconId = definition.Id;
			});
		}

		private string ListIcons(string query)
		{
			StringBuilder stringBuilder = new StringBuilder("Icons:");
			foreach (IconRegistry.IconDefinition item in IconRegistry.Search(query))
			{
				stringBuilder.Append("\n  " + item.Id + "  (" + item.DisplayName + ", " + item.DefaultCategory + ")");
			}
			return stringBuilder.ToString();
		}

		private string SetColor(RoadPoint position, string colorText)
		{
			string text = colorText.Trim().TrimStart(new char[1] { '#' });
			if (string.Equals(text, "clear", StringComparison.OrdinalIgnoreCase))
			{
				return EditNearest(position, "color cleared", delegate(AtlasPin pin)
				{
					pin.ColorArgb = null;
				});
			}
			if (!uint.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result) || (text.Length != 6 && text.Length != 8))
			{
				return "Usage: cc_pins color RRGGBB | AARRGGBB | clear";
			}
			if (text.Length == 6)
			{
				result |= 0xFF000000u;
			}
			int argb = (int)result;
			return EditNearest(position, "color #" + text, delegate(AtlasPin pin)
			{
				pin.ColorArgb = argb;
			});
		}

		private string SetSize(RoadPoint position, string sizeText)
		{
			if (!float.TryParse(sizeText.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return "Usage: cc_pins size <0.5..2.0>";
			}
			float clamped = Mathf.Clamp(result, 0.5f, 2f);
			return EditNearest(position, $"size {clamped:0.##}", delegate(AtlasPin pin)
			{
				pin.SizeScale = clamped;
			});
		}

		private string SetStatus(RoadPoint position, string statusText)
		{
			if (!Enum.TryParse<AtlasPinStatus>(statusText.Trim(), ignoreCase: true, out var status) || !Enum.IsDefined(typeof(AtlasPinStatus), status))
			{
				return "Usage: cc_pins setstatus none|todo|inprogress|done|warning";
			}
			return EditNearest(position, $"status {status}", delegate(AtlasPin pin)
			{
				pin.Status = status;
			});
		}

		private string SetScope(RoadPoint position, string scopeText)
		{
			if (!Enum.TryParse<AtlasScope>(scopeText.Trim(), ignoreCase: true, out var scope) || !Enum.IsDefined(typeof(AtlasScope), scope))
			{
				return "Usage: cc_pins scope private|table|server (sharing intent; sync arrives in v0.6)";
			}
			return EditNearest(position, $"scope {scope}", delegate(AtlasPin pin)
			{
				pin.Scope = scope;
			});
		}

		private string Move(RoadPoint position)
		{
			if (!TryFindNearest(position, 100f, includeArchived: true, out AtlasPin pin, out float _))
			{
				return "No managed pin within 100 m.";
			}
			_operations.Move(pin.Id, position);
			_adapter.SyncPin(_store, pin.Id);
			return "Moved " + Describe(pin) + " to your position. 'cc_pins undo' reverts.";
		}

		private string Duplicate(RoadPoint position)
		{
			if (!TryFindNearest(position, 15f, includeArchived: false, out AtlasPin pin, out float _))
			{
				return NoNearbyPin();
			}
			AtlasPin atlasPin = _operations.Duplicate(pin.Id);
			if (atlasPin == null)
			{
				return "Duplicate failed.";
			}
			_adapter.SyncPin(_store, atlasPin.Id);
			return "Duplicated as " + Describe(atlasPin) + " (offset 4 m east).";
		}

		private string Archive(RoadPoint position, bool archived)
		{
			AtlasPin atlasPin = null;
			float num = 15f;
			foreach (AtlasPin item in _store.Living)
			{
				if (item.Archived != archived)
				{
					float num2 = item.Position.HorizontalDistanceTo(in position);
					if (num2 <= num)
					{
						num = num2;
						atlasPin = item;
					}
				}
			}
			if (atlasPin == null)
			{
				if (!archived)
				{
					return $"No archived pin within {15f:0.#} m.";
				}
				return NoNearbyPin();
			}
			_operations.SetArchived(atlasPin.Id, archived);
			_adapter.SyncPin(_store, atlasPin.Id);
			return (archived ? "Archived" : "Unarchived") + " " + Describe(atlasPin) + ".";
		}

		private string Delete(RoadPoint position)
		{
			if (!TryFindNearest(position, 15f, includeArchived: true, out AtlasPin pin, out float _))
			{
				return NoNearbyPin();
			}
			_operations.Delete(pin.Id);
			_adapter.SyncPin(_store, pin.Id);
			return "Deleted " + Describe(pin) + ". 'cc_pins restore' or 'cc_pins undo' brings it back.";
		}

		private string Restore()
		{
			List<AtlasPin> list = _operations.RecentlyDeleted(1);
			if (list.Count == 0)
			{
				return "Nothing in the recently-deleted list.";
			}
			_operations.RestoreDeleted(list[0].Id);
			_adapter.SyncPin(_store, list[0].Id);
			return "Restored " + Describe(list[0]) + ".";
		}

		private string ListDeleted()
		{
			StringBuilder stringBuilder = new StringBuilder("Recently deleted:");
			List<AtlasPin> list = _operations.RecentlyDeleted();
			if (list.Count == 0)
			{
				return "Recently deleted: none.";
			}
			foreach (AtlasPin item in list)
			{
				stringBuilder.Append($"\n  {Describe(item)} (deleted {item.DeletedUtc:HH:mm} UTC)");
			}
			return stringBuilder.ToString();
		}

		private string ListDuplicates(string radiusText)
		{
			float num = ParseRadius(radiusText, 25f);
			List<List<AtlasPin>> list = _operations.FindDuplicateGroups(num);
			if (list.Count == 0)
			{
				return $"No likely duplicates within {num:0.#} m of each other.";
			}
			StringBuilder stringBuilder = new StringBuilder($"{list.Count} duplicate group(s):");
			foreach (List<AtlasPin> item in list)
			{
				stringBuilder.Append($"\n  keep {Describe(item[0])} <- merge {item.Count - 1} other(s)");
			}
			stringBuilder.Append("\nStand near a group and run 'cc_pins merge confirm'.");
			return stringBuilder.ToString();
		}

		private string Merge(RoadPoint position, string confirm)
		{
			List<List<AtlasPin>> list = _operations.FindDuplicateGroups(25f);
			List<AtlasPin> list2 = null;
			float num = float.MaxValue;
			foreach (List<AtlasPin> item in list)
			{
				float num2 = item[0].Position.HorizontalDistanceTo(in position);
				if (num2 < num)
				{
					num = num2;
					list2 = item;
				}
			}
			if (list2 == null)
			{
				return "No duplicate group found.";
			}
			if (!string.Equals(confirm.Trim(), "confirm", StringComparison.OrdinalIgnoreCase))
			{
				return $"Would merge {list2.Count - 1} pin(s) into {Describe(list2[0])}, preserving notes and provenance. " + "Run 'cc_pins merge confirm' to proceed.";
			}
			List<AtlasId> list3 = new List<AtlasId>();
			for (int i = 1; i < list2.Count; i++)
			{
				list3.Add(list2[i].Id);
			}
			_operations.Merge(list2[0].Id, list3);
			_resyncMap();
			return $"Merged {list3.Count} duplicate(s) into {Describe(list2[0])}. 'cc_pins undo' reverts.";
		}

		private string UndoRedo(bool undo)
		{
			if (undo ? _operations.Undo(out string summary) : _operations.Redo(out summary))
			{
				_resyncMap();
			}
			return summary;
		}

		private string Coordinates(RoadPoint position)
		{
			if (!TryFindNearest(position, 15f, includeArchived: true, out AtlasPin pin, out float _))
			{
				return NoNearbyPin();
			}
			string text = string.Format(CultureInfo.InvariantCulture, "{0:0.#}, {1:0.#}, {2:0.#}", pin.Position.X, pin.Position.Y, pin.Position.Z);
			try
			{
				GUIUtility.systemCopyBuffer = text;
			}
			catch
			{
			}
			return Describe(pin) + " at (" + text + ") — copied to clipboard.";
		}

		private bool TryFindNearest(RoadPoint position, float maxRadius, bool includeArchived, out AtlasPin? pin, out float distance)
		{
			pin = null;
			distance = float.MaxValue;
			foreach (AtlasPin item in _store.Living)
			{
				if (!item.Archived || includeArchived)
				{
					float num = item.Position.HorizontalDistanceTo(in position);
					if (num < distance)
					{
						distance = num;
						pin = item;
					}
				}
			}
			if (pin != null)
			{
				return distance <= maxRadius;
			}
			return false;
		}

		private static bool MatchesFilter(AtlasPin pin, string needle)
		{
			if (needle.Length == 0)
			{
				return true;
			}
			if (pin.Name.ToLowerInvariant().Contains(needle) || pin.Category.ToLowerInvariant().Contains(needle) || pin.IconId.ToLowerInvariant().Contains(needle))
			{
				return true;
			}
			foreach (string tag in pin.Tags)
			{
				if (tag.ToLowerInvariant().Contains(needle))
				{
					return true;
				}
			}
			return false;
		}

		private static float ParseRadius(string text, float fallback)
		{
			if (!float.TryParse(text.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return fallback;
			}
			return Mathf.Clamp(result, 1f, 200f);
		}

		private static string NoNearbyPin()
		{
			return $"No managed pin within {15f:0.#} m. 'cc_pins list' shows what exists; 'cc_pins adopt' adopts a vanilla pin.";
		}

		private static string Describe(AtlasPin pin)
		{
			string text = ((pin.Name.Length == 0) ? "(unnamed)" : ("\"" + pin.Name + "\""));
			string text2 = "";
			if (pin.Archived)
			{
				text2 += ", archived";
			}
			if (pin.Deleted)
			{
				text2 += ", deleted";
			}
			return $"{text} [{pin.IconId}, {pin.Source}{text2}]";
		}
	}
	internal sealed class PinToolsCommand : ConsoleCommand
	{
		private readonly CartographerRuntime _runtime;

		public override string Name => "cc_pins";

		public override string Help => "Concerned Cartographer pin workbench. Subcommands: edit (opens the panel), status, list, adopt, adoptall, create, name, icon, icons, category, color, size, note, tag+, tag-, setstatus, check, uncheck, scope, move, dup, archive, unarchive, delete, restore, deleted, dups, merge, undo, redo, coords. Most target the managed pin nearest you.";

		public PinToolsCommand(CartographerRuntime runtime)
		{
			_runtime = runtime;
		}

		public override void Run(string[] args, Terminal context)
		{
			string text;
			try
			{
				text = _runtime.ExecutePinCommand(args);
			}
			catch (Exception ex)
			{
				text = "Pin tool failed: " + ex.Message;
			}
			if (context != null)
			{
				context.AddString(text);
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string>
			{
				"edit", "status", "list", "adopt", "adoptall", "create", "name", "icon", "icons", "category",
				"color", "size", "note", "tag+", "tag-", "setstatus", "check", "uncheck", "scope", "move",
				"dup", "archive", "unarchive", "delete", "restore", "deleted", "dups", "merge", "undo", "redo",
				"coords"
			};
		}
	}
	internal sealed class QuickPinCapture
	{
		private readonly CartographerSettings _settings;

		private readonly ManualLogSource _log;

		public QuickPinCapture(CartographerSettings settings, ManualLogSource log)
		{
			_settings = settings;
			_log = log;
		}

		public bool TryCapture(PinStore store, out string message, out AtlasPin? created)
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			message = "";
			created = null;
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer == null)
				{
					return false;
				}
				GameObject hoverObject = ((Humanoid)localPlayer).GetHoverObject();
				if ((Object)(object)hoverObject == (Object)null)
				{
					message = AtlasStrings.Get("hud.quickPinNothing");
					return false;
				}
				if ((Object)(object)hoverObject.GetComponentInParent<Character>() != (Object)null)
				{
					message = AtlasStrings.Get("hud.quickPinCreature");
					return false;
				}
				string hoverName = "";
				Hoverable componentInParent = hoverObject.GetComponentInParent<Hoverable>();
				if (componentInParent != null)
				{
					try
					{
						hoverName = componentInParent.GetHoverName() ?? "";
					}
					catch
					{
						hoverName = "";
					}
				}
				List<string> list = new List<string> { ((Object)hoverObject).name };
				ZNetView componentInParent2 = hoverObject.GetComponentInParent<ZNetView>();
				if ((Object)(object)componentInParent2 != (Object)null && (Object)(object)((Component)componentInParent2).gameObject != (Object)null)
				{
					list.Add(((Object)((Component)componentInParent2).gameObject).name);
				}
				if ((Object)(object)hoverObject.transform.root != (Object)null)
				{
					list.Add(((Object)hoverObject.transform.root).name);
				}
				QuickPinSuggester.Suggestion suggestion = QuickPinSuggester.Suggest(hoverName, list);
				Vector3 position = hoverObject.transform.position;
				RoadPoint point = new RoadPoint(position.x, position.y, position.z);
				float value = _settings.QuickPinDuplicateRadius.Value;
				if (value > 0f)
				{
					foreach (AtlasPin item in store.Living)
					{
						if (!item.Archived && string.Equals(item.Name, suggestion.Name, StringComparison.OrdinalIgnoreCase) && item.Position.HorizontalDistanceTo(in point) <= value)
						{
							message = AtlasStrings.Format("hud.quickPinDuplicate", suggestion.Name, item.Position.HorizontalDistanceTo(in point).ToString("0.#"));
							return false;
						}
					}
				}
				AtlasPin atlasPin = (created = store.Create(delegate(AtlasPin newPin)
				{
					newPin.Name = suggestion.Name;
					newPin.IconId = suggestion.IconId;
					newPin.Category = suggestion.Category;
					newPin.Source = AtlasPinSource.Generated;
					newPin.Position = point;
				}));
				_log.LogInfo((object)$"Quick pin {atlasPin.Id}: {suggestion.IconId}.");
				message = AtlasStrings.Format("hud.quickPinned", suggestion.Name);
				return true;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Quick pin failed: " + SafeLogText.Describe(exception)));
				message = "Quick pin failed; see the log.";
				return false;
			}
		}
	}
	internal sealed class RateLimitedLog
	{
		private readonly ManualLogSource _log;

		private readonly float _minimumIntervalSeconds;

		private readonly Dictionary<string, float> _lastLoggedAt = new Dictionary<string, float>();

		public RateLimitedLog(ManualLogSource log, float minimumIntervalSeconds)
		{
			_log = log;
			_minimumIntervalSeconds = minimumIntervalSeconds;
		}

		public void Info(string key, string message)
		{
			if (ShouldLog(key))
			{
				_log.LogInfo((object)message);
			}
		}

		public void Warning(string key, string message)
		{
			if (ShouldLog(key))
			{
				_log.LogWarning((object)message);
			}
		}

		public void Error(string key, string message)
		{
			if (ShouldLog(key))
			{
				_log.LogError((object)message);
			}
		}

		private bool ShouldLog(string key)
		{
			float unscaledTime = Time.unscaledTime;
			if (_lastLoggedAt.TryGetValue(key, out var value) && unscaledTime - value < _minimumIntervalSeconds)
			{
				return false;
			}
			_lastLoggedAt[key] = unscaledTime;
			return true;
		}
	}
	internal sealed class RoadToolsCommand : ConsoleCommand
	{
		private readonly CartographerRuntime _runtime;

		public override string Name => "cc_roads";

		public override string Help => "Concerned Cartographer road tools. Subcommands: status, delete, kind, hide, unhide, split, join, rebuild, undo. Each targets the recorded road nearest you; an optional number sets the search radius in meters (e.g. 'cc_roads delete 20'). 'align' runs the map-alignment diagnostic (native pin vs overlay cross); 'align live' runs the end-to-end player-vs-road-ink diagnosis (A/B/C/D verdicts); 'align clear' removes the pins.";

		public RoadToolsCommand(CartographerRuntime runtime)
		{
			_runtime = runtime;
		}

		public override void Run(string[] args, Terminal context)
		{
			string text;
			try
			{
				text = _runtime.ExecuteRoadCommand(args);
			}
			catch (Exception ex)
			{
				text = "Road tool failed: " + ex.Message;
			}
			if (context != null)
			{
				context.AddString(text);
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string> { "status", "delete", "kind", "hide", "unhide", "split", "join", "rebuild", "undo", "align" };
		}
	}
	internal sealed class RouteCommandHandler
	{
		public enum MapMode
		{
			None,
			Draw,
			Erase,
			Waypoint
		}

		private readonly RouteStore _store;

		private readonly RouteOperations _operations;

		private readonly RoadAtlas _roads;

		private readonly CartographerSettings _settings;

		private readonly ManualLogSource _log;

		private readonly Action _redraw;

		private RouteKind _uiPendingKind = RouteKind.Freehand;

		private string _uiBaseName = "";

		private int _uiStrokeCount;

		private readonly FreeDrawStrokeGate _strokeGate = new FreeDrawStrokeGate();

		private bool _uiRouteStarted;

		public MapMode Mode { get; private set; }

		public AtlasId ActiveRouteId { get; private set; }

		public bool SnapEnabled { get; private set; } = true;

		public RouteOperations Operations => _operations;

		public long ChangeStamp => _store.ChangeStamp;

		public bool UiModeOwned { get; private set; }

		public string ActiveRouteDisplayName
		{
			get
			{
				if (_uiRouteStarted && _store.TryGet(ActiveRouteId, out AtlasRoute route) && !route.Deleted)
				{
					return route.Name;
				}
				if (_uiBaseName.Length <= 0)
				{
					return "New route";
				}
				return _uiBaseName;
			}
		}

		public RouteCommandHandler(RouteStore store, RouteOperations operations, RoadAtlas roads, CartographerSettings settings, ManualLogSource log, Action redraw)
		{
			_store = store;
			_operations = operations;
			_roads = roads;
			_settings = settings;
			_log = log;
			_redraw = redraw;
		}

		public string UiStart(RouteKind kind, string name)
		{
			Mode = ((kind == RouteKind.Freehand) ? MapMode.Draw : MapMode.Waypoint);
			UiModeOwned = true;
			_uiPendingKind = kind;
			_uiBaseName = ((name.Trim().Length == 0) ? "New route" : name.Trim());
			_uiStrokeCount = 0;
			_uiRouteStarted = false;
			_strokeGate.Reset();
			return _uiBaseName;
		}

		public void UiStartErase()
		{
			Mode = MapMode.Erase;
			UiModeOwned = true;
			_strokeGate.Reset();
		}

		public void UiStop()
		{
			Mode = MapMode.None;
			UiModeOwned = false;
			_strokeGate.Reset();
			_redraw();
		}

		public void UiSetSnap(bool enabled)
		{
			SnapEnabled = enabled;
		}

		public List<(AtlasId Id, string Label)> UiListRoutes(int max)
		{
			List<AtlasRoute> list = new List<AtlasRoute>(_store.Living);
			list.Sort(delegate(AtlasRoute left, AtlasRoute right)
			{
				int num = left.Archived.CompareTo(right.Archived);
				if (num != 0)
				{
					return num;
				}
				int num2 = string.Compare(left.Name, right.Name, StringComparison.OrdinalIgnoreCase);
				return (num2 == 0) ? left.Id.Value.CompareTo(right.Id.Value) : num2;
			});
			List<(AtlasId, string)> list2 = new List<(AtlasId, string)>();
			foreach (AtlasRoute item in list)
			{
				if (list2.Count >= max)
				{
					break;
				}
				RouteEstimator.Estimate estimate = RouteEstimator.Compute(item.Points, _roads, _settings.RouteOnRoadTolerance.Value, _settings.RouteOffRoadSpeed.Value, _settings.RouteOnRoadSpeed.Value);
				string text = (item.Locked ? " L" : "") + (item.Archived ? " A" : "");
				list2.Add((item.Id, $"{item.Name} [{item.Kind} · {item.Style} · {item.Status}]{text} {estimate.DistanceMeters:0} m"));
			}
			return list2;
		}

		public int LivingRouteCount()
		{
			int num = 0;
			foreach (AtlasRoute item in _store.Living)
			{
				_ = item;
				num++;
			}
			return num;
		}

		public string UiClearAll()
		{
			if (Mode != MapMode.None)
			{
				UiStop();
			}
			List<AtlasId> list = new List<AtlasId>();
			foreach (AtlasRoute item in _store.Living)
			{
				list.Add(item.Id);
			}
			foreach (AtlasId item2 in list)
			{
				_operations.Delete(item2);
			}
			_redraw();
			if (list.Count != 0)
			{
				return $"Deleted {list.Count} route(s). Restore or Undo brings them back one at a time.";
			}
			return "No routes to clear.";
		}

		public string UiRename(AtlasId id, string name)
		{
			return UiEdit(id, delegate(AtlasRoute route)
			{
				route.Name = name.Trim();
			}, "renamed to \"" + name.Trim() + "\"");
		}

		public string UiCycleStyle(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			RouteStyle next = ((route.Style == RouteStyle.Dotted) ? RouteStyle.Solid : (route.Style + 1));
			return UiEdit(id, delegate(AtlasRoute r)
			{
				r.Style = next;
			}, $"style {next}");
		}

		public string UiCycleStatus(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			RouteStatus next = ((route.Status == RouteStatus.Done) ? RouteStatus.Planned : (route.Status + 1));
			return UiEdit(id, delegate(AtlasRoute r)
			{
				r.Status = next;
			}, $"status {next}");
		}

		public string UiSetColor(AtlasId id, int? argb)
		{
			return UiEdit(id, delegate(AtlasRoute route)
			{
				route.ColorArgb = argb;
			}, (!argb.HasValue) ? "color cleared" : "color set");
		}

		public string UiToggleLock(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			bool flag = !route.Locked;
			_operations.SetLocked(id, flag);
			return "\"" + route.Name + "\" " + (flag ? "locked (geometry edits rejected)" : "unlocked") + ".";
		}

		public string UiToggleArchive(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			bool flag = !route.Archived;
			_operations.SetArchived(id, flag);
			_redraw();
			return "\"" + route.Name + "\" " + (flag ? "archived (hidden from the map)" : "unarchived") + ".";
		}

		public string UiDelete(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			if (Mode != MapMode.None && ActiveRouteId.Equals(id))
			{
				UiStop();
			}
			_operations.Delete(id);
			_redraw();
			return "Deleted \"" + route.Name + "\". Restore or Undo reverts.";
		}

		public string UiRestoreLatest()
		{
			AtlasRoute atlasRoute = null;
			foreach (AtlasRoute item in _store.All)
			{
				if (item.Deleted && (atlasRoute == null || (item.DeletedUtc ?? DateTime.MinValue) > (atlasRoute.DeletedUtc ?? DateTime.MinValue)))
				{
					atlasRoute = item;
				}
			}
			if (atlasRoute != null)
			{
				_operations.RestoreDeleted(atlasRoute.Id);
				_redraw();
				return "Restored \"" + atlasRoute.Name + "\".";
			}
			return "No deleted route to restore.";
		}

		public string UiSplit(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			if (route.Points.Count < 3)
			{
				return "That route is too short to split.";
			}
			if (_operations.Split(id, route.Points.Count / 2) == null)
			{
				if (!route.Locked)
				{
					return "Split failed.";
				}
				return "The route is locked.";
			}
			_redraw();
			return "Split \"" + route.Name + "\" at its midpoint.";
		}

		public string UiMerge(AtlasId keep, AtlasId absorbed)
		{
			if (keep.Equals(absorbed))
			{
				return "Pick two different routes to merge.";
			}
			if (!_store.TryGet(keep, out AtlasRoute route) || !_store.TryGet(absorbed, out AtlasRoute route2))
			{
				return "Route no longer exists.";
			}
			if (!_operations.Merge(keep, absorbed))
			{
				return "Merge failed (locked or empty route).";
			}
			_redraw();
			return "Merged \"" + route2.Name + "\" into \"" + route.Name + "\". Undo reverts.";
		}

		public string UiMeasure(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			RouteEstimator.Estimate estimate = RouteEstimator.Compute(route.Points, _roads, _settings.RouteOnRoadTolerance.Value, _settings.RouteOffRoadSpeed.Value, _settings.RouteOnRoadSpeed.Value);
			return $"\"{route.Name}\": {estimate.DistanceMeters:0} m, {estimate.OnRoadFraction:P0} on roads, " + $"≈{estimate.EstimatedMinutes:0.#} min.";
		}

		public bool UiUndo(out string summary)
		{
			bool num = _operations.Undo(out summary);
			if (num)
			{
				_redraw();
			}
			return num;
		}

		public bool UiRedo(out string summary)
		{
			bool num = _operations.Redo(out summary);
			if (num)
			{
				_redraw();
			}
			return num;
		}

		private string UiEdit(AtlasId id, Action<AtlasRoute> edit, string description)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return "Route no longer exists.";
			}
			_operations.EditMetadata(id, edit, description);
			_redraw();
			return "\"" + route.Name + "\": " + description + ".";
		}

		public void HandleMapFrame(RoadPoint cursorWorld, bool actionHeld, bool actionClicked)
		{
			switch (Mode)
			{
			case MapMode.Draw:
			{
				if (!UiModeOwned)
				{
					if (actionHeld && _operations.AppendPoint(ActiveRouteId, cursorWorld))
					{
						_redraw();
					}
					break;
				}
				FreeDrawStrokeGate.Decision decision = _strokeGate.Observe(actionHeld, cursorWorld);
				if (decision.Kind == FreeDrawStrokeGate.DecisionKind.StartStroke)
				{
					StartUiStroke();
					_operations.AppendPoint(ActiveRouteId, decision.StrokeStart);
					_operations.AppendPoint(ActiveRouteId, cursorWorld);
					_redraw();
				}
				else if (decision.Kind == FreeDrawStrokeGate.DecisionKind.Append && _operations.AppendPoint(ActiveRouteId, cursorWorld))
				{
					_redraw();
				}
				break;
			}
			case MapMode.Erase:
			{
				if (!actionHeld)
				{
					break;
				}
				int num = 0;
				foreach (AtlasRoute item in new List<AtlasRoute>(_store.Living))
				{
					num += _operations.EraseNear(item.Id, cursorWorld, _settings.RouteEraseRadius.Value, out List<AtlasRoute> _);
				}
				if (num > 0)
				{
					_redraw();
				}
				break;
			}
			case MapMode.Waypoint:
				if (actionClicked)
				{
					if (UiModeOwned && !_uiRouteStarted)
					{
						AtlasRoute atlasRoute = _operations.StartRoute(RouteKind.Waypoint, _uiBaseName);
						ActiveRouteId = atlasRoute.Id;
						_uiRouteStarted = true;
					}
					AddWaypoint(cursorWorld);
				}
				break;
			}
		}

		private void StartUiStroke()
		{
			_uiStrokeCount++;
			string name = ((_uiStrokeCount == 1) ? _uiBaseName : $"{_uiBaseName} {_uiStrokeCount}");
			AtlasRoute atlasRoute = _operations.StartRoute(RouteKind.Freehand, name);
			ActiveRouteId = atlasRoute.Id;
			_uiRouteStarted = true;
		}

		private void AddWaypoint(RoadPoint cursorWorld)
		{
			RoadPoint roadPoint = cursorWorld;
			if (SnapEnabled && _roads.TryGetNearestPointOnRoads(cursorWorld, _settings.RouteSnapRadius.Value, out var nearest, out var _))
			{
				roadPoint = nearest;
			}
			if (!_store.TryGet(ActiveRouteId, out AtlasRoute route))
			{
				return;
			}
			if (SnapEnabled && route.Points.Count > 0)
			{
				RoadPoint start = route.Points[route.Points.Count - 1];
				List<RoadPoint> list = RoadGraphRouter.FindPath(_roads, start, roadPoint, _settings.RouteSnapRadius.Value);
				if (list != null && list.Count > 2)
				{
					for (int i = 1; i < list.Count; i++)
					{
						_operations.AppendPoint(ActiveRouteId, list[i]);
					}
					_redraw();
					return;
				}
			}
			_operations.AppendPoint(ActiveRouteId, roadPoint);
			_redraw();
		}

		public string Execute(string[] args, Vector3 playerPosition)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			RoadPoint player = new RoadPoint(playerPosition.x, playerPosition.y, playerPosition.z);
			string text = ((args.Length == 0) ? "list" : args[0].ToLowerInvariant());
			string remainder = ((args.Length > 1) ? string.Join(" ", args, 1, args.Length - 1) : "");
			switch (text)
			{
			case "list":
				return ListRoutes(player);
			case "draw":
			case "waypoint":
			{
				AtlasRoute atlasRoute = _operations.StartRoute((text == "draw") ? RouteKind.Freehand : RouteKind.Waypoint, (remainder.Trim().Length == 0) ? "New route" : remainder.Trim());
				ActiveRouteId = atlasRoute.Id;
				Mode = ((text == "draw") ? MapMode.Draw : MapMode.Waypoint);
				UiModeOwned = false;
				_uiBaseName = atlasRoute.Name;
				_uiRouteStarted = true;
				_strokeGate.Reset();
				if (!(text == "draw"))
				{
					return string.Format("Waypoint route \"{0}\": {1}+LeftClick places waypoints (snap {2}). 'cc_routes stop' finishes.", atlasRoute.Name, _settings.RouteDrawModifier.Value, SnapEnabled ? "on" : "off");
				}
				return $"Drawing \"{atlasRoute.Name}\": open the large map and hold {_settings.RouteDrawModifier.Value}+LeftClick to draw. 'cc_routes stop' finishes.";
			}
			case "erase":
				Mode = MapMode.Erase;
				UiModeOwned = false;
				return $"Erase mode: hold {_settings.RouteDrawModifier.Value}+LeftClick on the map to erase route ink " + $"({_settings.RouteEraseRadius.Value:0.#} m radius). 'cc_routes stop' finishes.";
			case "stop":
				Mode = MapMode.None;
				UiModeOwned = false;
				_redraw();
				return "Route mode off.";
			case "snap":
				if (remainder.Trim().ToLowerInvariant() == "on")
				{
					SnapEnabled = true;
				}
				else
				{
					if (!(remainder.Trim().ToLowerInvariant() == "off"))
					{
						return "Usage: cc_routes snap on|off";
					}
					SnapEnabled = false;
				}
				return "Road-aware snapping " + (SnapEnabled ? "on" : "off") + ".";
			case "measure":
				return Measure(player);
			case "name":
				return EditNearest(player, delegate(AtlasRoute atlasRoute2)
				{
					atlasRoute2.Name = remainder.Trim();
				}, "renamed to \"" + remainder.Trim() + "\"");
			case "style":
			{
				if (!Enum.TryParse<RouteStyle>(remainder.Trim(), ignoreCase: true, out var style) || !Enum.IsDefined(typeof(RouteStyle), style))
				{
					return "Usage: cc_routes style solid|dashed|dotted";
				}
				return EditNearest(player, delegate(AtlasRoute atlasRoute2)
				{
					atlasRoute2.Style = style;
				}, $"style {style}");
			}
			case "status":
			{
				if (!Enum.TryParse<RouteStatus>(remainder.Trim(), ignoreCase: true, out var status) || !Enum.IsDefined(typeof(RouteStatus), status))
				{
					return "Usage: cc_routes status planned|active|done";
				}
				return EditNearest(player, delegate(AtlasRoute atlasRoute2)
				{
					atlasRoute2.Status = status;
				}, $"status {status}");
			}
			case "color":
			{
				string text2 = remainder.Trim().TrimStart(new char[1] { '#' });
				if (string.Equals(text2, "clear", StringComparison.OrdinalIgnoreCase))
				{
					return EditNearest(player, delegate(AtlasRoute atlasRoute2)
					{
						atlasRoute2.ColorArgb = null;
					}, "color cleared");
				}
				if ((text2.Length == 6 || text2.Length == 8) && uint.TryParse(text2, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
				{
					if (text2.Length == 6)
					{
						result |= 0xFF000000u;
					}
					int argb = (int)result;
					return EditNearest(player, delegate(AtlasRoute atlasRoute2)
					{
						atlasRoute2.ColorArgb = argb;
					}, "color #" + text2);
				}
				return "Usage: cc_routes color RRGGBB|AARRGGBB|clear";
			}
			case "lock":
				return LockNearest(player, locked: true);
			case "unlock":
				return LockNearest(player, locked: false);
			case "archive":
				return ArchiveNearest(player, archived: true);
			case "unarchive":
				return ArchiveNearest(player, archived: false);
			case "delete":
			{
				if (!TryFindNearest(player, out AtlasRoute route, out float _))
				{
					return NoNearbyRoute();
				}
				Mode = ((Mode == MapMode.None) ? Mode : MapMode.None);
				_operations.Delete(route.Id);
				_redraw();
				return "Deleted route \"" + route.Name + "\". 'cc_routes undo' or 'cc_routes restore' reverts.";
			}
			case "restore":
				foreach (AtlasRoute item in _store.All)
				{
					if (item.Deleted)
					{
						_operations.RestoreDeleted(item.Id);
						_redraw();
						return "Restored route \"" + item.Name + "\".";
					}
				}
				return "No deleted route to restore.";
			case "split":
				return SplitNearest(player);
			case "merge":
				return MergeNearest(player);
			case "undo":
			{
				if (_operations.Undo(out string summary2))
				{
					_redraw();
				}
				return summary2;
			}
			case "redo":
			{
				if (_operations.Redo(out string summary))
				{
					_redraw();
				}
				return summary;
			}
			default:
				return "Usage: cc_routes [list|draw <name>|waypoint <name>|erase|stop|snap on/off|measure|name|style|status|color|lock|unlock|archive|unarchive|delete|restore|split|merge|undo|redo]";
			}
		}

		private string ListRoutes(RoadPoint player)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (AtlasRoute item in _store.Living)
			{
				num++;
				if (num <= 12)
				{
					RouteEstimator.Estimate estimate = RouteEstimator.Compute(item.Points, _roads, _settings.RouteOnRoadTolerance.Value, _settings.RouteOffRoadSpeed.Value, _settings.RouteOnRoadSpeed.Value);
					stringBuilder.Append($"\n  \"{item.Name}\" [{item.Kind}, {item.Style}, {item.Status}" + (item.Locked ? ", locked" : "") + (item.Archived ? ", archived" : "") + "] " + $"{item.Points.Count} pts, {estimate.DistanceMeters:0} m");
				}
			}
			string text = ((Mode == MapMode.None) ? "" : $" Mode: {Mode} (cc_routes stop ends it).");
			if (num != 0)
			{
				return $"{num} route(s):{stringBuilder}{text}";
			}
			return "No routes yet. 'cc_routes draw <name>' or 'cc_routes waypoint <name>' starts one." + text;
		}

		private string Measure(RoadPoint player)
		{
			if (!TryFindNearest(player, out AtlasRoute route, out float _))
			{
				return NoNearbyRoute();
			}
			RouteEstimator.Estimate estimate = RouteEstimator.Compute(route.Points, _roads, _settings.RouteOnRoadTolerance.Value, _settings.RouteOffRoadSpeed.Value, _settings.RouteOnRoadSpeed.Value);
			return $"\"{route.Name}\": {estimate.DistanceMeters:0} m, {estimate.OnRoadFraction:P0} on roads, " + $"≈{estimate.EstimatedMinutes:0.#} min at {_settings.RouteOffRoadSpeed.Value:0.#}/{_settings.RouteOnRoadSpeed.Value:0.#} m/s.";
		}

		private string EditNearest(RoadPoint player, Action<AtlasRoute> edit, string description)
		{
			if (!TryFindNearest(player, out AtlasRoute route, out float _))
			{
				return NoNearbyRoute();
			}
			_operations.EditMetadata(route.Id, edit, description);
			_redraw();
			return "Route \"" + route.Name + "\": " + description + ".";
		}

		private string LockNearest(RoadPoint player, bool locked)
		{
			if (!TryFindNearest(player, out AtlasRoute route, out float _))
			{
				return NoNearbyRoute();
			}
			_operations.SetLocked(route.Id, locked);
			return "Route \"" + route.Name + "\" " + (locked ? "locked (geometry edits rejected)" : "unlocked") + ".";
		}

		private string ArchiveNearest(RoadPoint player, bool archived)
		{
			AtlasRoute atlasRoute = null;
			float num = 100f;
			foreach (AtlasRoute item in _store.Living)
			{
				if (item.Archived != archived)
				{
					float num2 = DistanceToRoute(item, player);
					if (num2 <= num)
					{
						num = num2;
						atlasRoute = item;
					}
				}
			}
			if (atlasRoute == null)
			{
				if (!archived)
				{
					return "No archived route within 100 m.";
				}
				return NoNearbyRoute();
			}
			_operations.SetArchived(atlasRoute.Id, archived);
			_redraw();
			return "Route \"" + atlasRoute.Name + "\" " + (archived ? "archived (hidden from the map)" : "unarchived") + ".";
		}

		private string SplitNearest(RoadPoint player)
		{
			if (!TryFindNearest(player, out AtlasRoute route, out float _))
			{
				return NoNearbyRoute();
			}
			int num = -1;
			float num2 = float.MaxValue;
			for (int i = 1; i < route.Points.Count - 1; i++)
			{
				float num3 = route.Points[i].HorizontalDistanceTo(in player);
				if (num3 < num2)
				{
					num2 = num3;
					num = i;
				}
			}
			if (num < 0)
			{
				return "That route is too short to split.";
			}
			if (_operations.Split(route.Id, num) == null)
			{
				if (!route.Locked)
				{
					return "Split failed.";
				}
				return "The route is locked.";
			}
			_redraw();
			return "Split \"" + route.Name + "\" at the point nearest you.";
		}

		private string MergeNearest(RoadPoint player)
		{
			AtlasRoute atlasRoute = null;
			AtlasRoute atlasRoute2 = null;
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			foreach (AtlasRoute item in _store.Living)
			{
				float num3 = DistanceToRoute(item, player);
				if (num3 < num)
				{
					atlasRoute2 = atlasRoute;
					num2 = num;
					atlasRoute = item;
					num = num3;
				}
				else if (num3 < num2)
				{
					atlasRoute2 = item;
					num2 = num3;
				}
			}
			if (atlasRoute == null || atlasRoute2 == null || num2 > 100f)
			{
				return "Stand near the two routes to merge (both within 100 m).";
			}
			if (!_operations.Merge(atlasRoute.Id, atlasRoute2.Id))
			{
				return "Merge failed (locked or empty route).";
			}
			_redraw();
			return "Merged \"" + atlasRoute2.Name + "\" into \"" + atlasRoute.Name + "\". 'cc_routes undo' reverts.";
		}

		private bool TryFindNearest(RoadPoint player, out AtlasRoute? route, out float distance)
		{
			route = null;
			distance = float.MaxValue;
			if (Mode != MapMode.None && _store.TryGet(ActiveRouteId, out AtlasRoute route2) && !route2.Deleted)
			{
				route = route2;
				distance = 0f;
				return true;
			}
			foreach (AtlasRoute item in _store.Living)
			{
				float num = DistanceToRoute(item, player);
				if (num < distance)
				{
					distance = num;
					route = item;
				}
			}
			if (route != null)
			{
				return distance <= 100f;
			}
			return false;
		}

		private static float DistanceToRoute(AtlasRoute route, RoadPoint position)
		{
			float num = float.MaxValue;
			for (int i = 0; i < Math.Max(1, route.Points.Count - 1); i++)
			{
				if (route.Points.Count == 0)
				{
					break;
				}
				RoadPoint roadPoint = route.Points[i];
				RoadPoint end = ((i + 1 < route.Points.Count) ? route.Points[i + 1] : roadPoint);
				num = Math.Min(num, RoadGeometry.HorizontalDistanceToSegment(position, roadPoint, end));
			}
			return num;
		}

		private static string NoNearbyRoute()
		{
			return "No route within 100 m. 'cc_routes list' shows what exists.";
		}
	}
	internal sealed class RouteToolsCommand : ConsoleCommand
	{
		private readonly CartographerRuntime _runtime;

		public override string Name => "cc_routes";

		public override string Help => "Concerned Cartographer routes. Subcommands: list, draw <name>, waypoint <name>, erase, stop, snap on|off, measure, name, style, status, color, lock, unlock, archive, unarchive, delete, restore, split, merge, undo, redo. Map modes use Modifier+LeftClick (default LeftShift).";

		public RouteToolsCommand(CartographerRuntime runtime)
		{
			_runtime = runtime;
		}

		public override void Run(string[] args, Terminal context)
		{
			string text;
			try
			{
				text = _runtime.ExecuteRouteCommand(args);
			}
			catch (Exception ex)
			{
				text = "Route tool failed: " + ex.Message;
			}
			if (context != null)
			{
				context.AddString(text);
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string>
			{
				"list", "draw", "waypoint", "erase", "stop", "snap", "measure", "name", "style", "status",
				"color", "lock", "unlock", "archive", "unarchive", "delete", "restore", "split", "merge", "undo",
				"redo"
			};
		}
	}
	internal sealed class SurveyScanner
	{
		private const int PerTickExamineBudget = 48;

		private const float NotifyCoalesceSeconds = 10f;

		private static readonly FieldRef<ZNetScene, Dictionary<ZDO, ZNetView>>? InstancesField = BuildInstancesRef();

		private readonly CartographerSettings _settings;

		private readonly ManualLogSource _log;

		private readonly List<ZNetView> _buffer = new List<ZNetView>();

		private int _cursor;

		private int _sweepExamined;

		private int _sweepAdded;

		private float _notifyElapsed = 10f;

		private int _unnotifiedAdded;

		private bool _disabledForSession;

		public DateTime? LastScanUtc { get; private set; }

		public int LastScanExamined { get; private set; }

		public int LastScanAdded { get; private set; }

		public bool DisabledForSession => _disabledForSession;

		public SurveyScanner(CartographerSettings settings, ManualLogSource log)
		{
			_settings = settings;
			_log = log;
		}

		public void RequestImmediateScan()
		{
			_buffer.Clear();
		}

		public void Tick(float deltaTime, SurveyEngine engine, PinStore pins)
		{
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			if (_disabledForSession || !_settings.SurveyRulesEnabled.Value)
			{
				return;
			}
			_notifyElapsed += deltaTime;
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer == null || InstancesField == null || (Object)(object)ZNetScene.instance == (Object)null)
				{
					return;
				}
				DateTime utcNow = DateTime.UtcNow;
				if (_buffer.Count == 0 || _cursor >= _buffer.Count)
				{
					if (_buffer.Count > 0)
					{
						LastScanUtc = utcNow;
						LastScanExamined = _sweepExamined;
						LastScanAdded = _sweepAdded;
					}
					_sweepExamined = 0;
					_sweepAdded = 0;
					_cursor = 0;
					engine.MaxObservations = _settings.SurveyMaxObservations.Value;
					engine.BaseExclusionRadiusMeters = _settings.SurveyBaseExclusionRadius.Value;
					engine.Prune(utcNow);
					_buffer.Clear();
					foreach (KeyValuePair<ZDO, ZNetView> item in InstancesField.Invoke(ZNetScene.instance))
					{
						_buffer.Add(item.Value);
					}
					if (_buffer.Count == 0)
					{
						return;
					}
				}
				Vector3 position = ((Component)localPlayer).transform.position;
				float value = _settings.SurveyScanRadius.Value;
				for (int num = Math.Min(_cursor + 48, _buffer.Count); _cursor < num; _cursor++)
				{
					_sweepExamined++;
					ZNetView val = _buffer[_cursor];
					if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
					{
						continue;
					}
					Vector3 position2 = ((Component)val).transform.position;
					if (!(Vector3.Distance(position2, position) > value) && !((Object)(object)((Component)val).GetComponent<Character>() != (Object)null))
					{
						switch (engine.Offer(((Object)((Component)val).gameObject).name, new RoadPoint(position2.x, position2.y, position2.z), pins, utcNow))
						{
						case SurveyEngine.OfferResult.Added:
							_sweepAdded++;
							_unnotifiedAdded++;
							continue;
						case SurveyEngine.OfferResult.CapReached:
							break;
						default:
							continue;
						}
						_cursor = _buffer.Count;
						break;
					}
				}
				if (_unnotifiedAdded > 0 && _notifyElapsed >= 10f)
				{
					((Character)localPlayer).Message((MessageType)1, AtlasStrings.Format("hud.surveyObservations", _unnotifiedAdded), 0, (Sprite)null);
					_unnotifiedAdded = 0;
					_notifyElapsed = 0f;
				}
			}
			catch (Exception exception)
			{
				_disabledForSession = true;
				_log.LogError((object)("Survey scanner failed and was disabled for this session: " + SafeLogText.Describe(exception)));
			}
		}

		public static bool AnyInstanceNear(string prefabNameFragment, Vector3 position, float radius)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (InstancesField == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			try
			{
				foreach (KeyValuePair<ZDO, ZNetView> item in InstancesField.Invoke(ZNetScene.instance))
				{
					ZNetView value = item.Value;
					if ((Object)(object)value != (Object)null && (Object)(object)((Component)value).gameObject != (Object)null && ((Object)((Component)value).gameObject).name.IndexOf(prefabNameFragment, StringComparison.OrdinalIgnoreCase) >= 0 && Vector3.Distance(((Component)value).transform.position, position) <= radius)
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static FieldRef<ZNetScene, Dictionary<ZDO, ZNetView>>? BuildInstancesRef()
		{
			try
			{
				return AccessTools.FieldRefAccess<ZNetScene, Dictionary<ZDO, ZNetView>>("m_instances");
			}
			catch
			{
				return null;
			}
		}
	}
	internal sealed class SurveyToolsCommand : ConsoleCommand
	{
		private readonly CartographerRuntime _runtime;

		public override string Name => "cc_survey";

		public override string Help => "Concerned Cartographer survey review. Subcommands: status, list, accept <n|all>, reject <n|all>, reload, path. Enable via Survey/SurveyRulesEnabled; rules live in survey-rules.tsv.";

		public SurveyToolsCommand(CartographerRuntime runtime)
		{
			_runtime = runtime;
		}

		public override void Run(string[] args, Terminal context)
		{
			string text;
			try
			{
				text = _runtime.ExecuteSurveyCommand(args);
			}
			catch (Exception ex)
			{
				text = "Survey tool failed: " + ex.Message;
			}
			if (context != null)
			{
				context.AddString(text);
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string> { "status", "list", "accept", "reject", "reload", "path" };
		}
	}
	internal sealed class SyncToolsCommand : ConsoleCommand
	{
		private readonly CartographerRuntime _runtime;

		public override string Name => "cc_sync";

		public override string Help => "Concerned Cartographer atlas sharing. Subcommands: status, share, inbox, preview <author>, apply <author> [mine|theirs], clear. Only pins/routes scoped table/server travel; deletions propagate as tombstones and can never resurrect.";

		public SyncToolsCommand(CartographerRuntime runtime)
		{
			_runtime = runtime;
		}

		public override void Run(string[] args, Terminal context)
		{
			string text;
			try
			{
				text = _runtime.ExecuteSyncCommand(args);
			}
			catch (Exception ex)
			{
				text = "Sync tool failed: " + ex.Message;
			}
			if (context != null)
			{
				context.AddString(text);
			}
		}

		public override List<string> CommandOptionList()
		{
			return new List<string> { "status", "share", "inbox", "preview", "apply", "clear" };
		}
	}
	internal sealed class SyncTransport
	{
		private const string RpcName = "CC_AtlasShare";

		private const int ProtocolVersion = 1;

		private const int MaxCompressedBytes = 320000;

		private const int MaxDecompressedBytes = 4000000;

		private const int MaxRows = 20000;

		private readonly ManualLogSource _log;

		private readonly SyncInbox _inbox;

		private bool _registered;

		private bool _disabledForSession;

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

		public SyncTransport(ManualLogSource log, SyncInbox inbox)
		{
			_log = log;
			_inbox = inbox;
		}

		public void EnsureRegistered()
		{
			if (_registered || _disabledForSession || ZRoutedRpc.instance == null)
			{
				return;
			}
			try
			{
				ZRoutedRpc.instance.Register<ZPackage>("CC_AtlasShare", (Action<long, ZPackage>)OnShareReceived);
				_registered = true;
			}
			catch (Exception exception)
			{
				Disable(exception);
			}
		}

		public bool Share(string authorId, string authorName, IReadOnlyList<AtlasPin> pins, IReadOnlyList<AtlasRoute> routes, out string message)
		{
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			message = "";
			if (_disabledForSession || !_registered || ZRoutedRpc.instance == null)
			{
				message = "Sync transport is unavailable this session.";
				return false;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("PINS");
				foreach (AtlasPin pin in pins)
				{
					stringBuilder.AppendLine(PinCodec.SerializeRow(pin));
				}
				stringBuilder.AppendLine("ROUTES");
				foreach (AtlasRoute route in routes)
				{
					foreach (string item in RouteCodec.SerializeRoute(route))
					{
						stringBuilder.AppendLine(item);
					}
				}
				byte[] array = AtlasCompression.Compress(Encoding.UTF8.GetBytes(stringBuilder.ToString()));
				if (array.Length > 320000)
				{
					message = $"The shared atlas is too large to broadcast ({array.Length / 1024} KB compressed). " + "Reduce the shared scope or archive old shared entities.";
					return false;
				}
				ZPackage val = new ZPackage();
				val.Write(1);
				val.Write(authorId);
				val.Write(authorName);
				val.Write(array.Length);
				val.Write(array);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "CC_AtlasShare", new object[1] { val });
				message = $"Shared {pins.Count} pin(s) and {routes.Count} route(s) to all connected players.";
				return true;
			}
			catch (Exception exception)
			{
				Disable(exception);
				message = "Sharing failed; see the log.";
				return false;
			}
		}

		private void OnShareReceived(long sender, ZPackage package)
		{
			if (_disabledForSession)
			{
				return;
			}
			try
			{
				int num = package.ReadInt();
				if (num != 1)
				{
					_log.LogWarning((object)$"Ignored an atlas share with protocol version {num} (mine is {1}).");
					return;
				}
				string text = AtlasText.SanitizeDisplay(package.ReadString(), 64);
				string text2 = AtlasText.SanitizeDisplay(package.ReadString(), 24);
				if (LocalAuthorId.Length > 0 && string.Equals(text, LocalAuthorId, StringComparison.Ordinal))
				{
					return;
				}
				int num2 = package.ReadInt();
				if (num2 <= 0 || num2 > 320000)
				{
					_log.LogWarning((object)"Ignored an oversized or empty atlas share.");
					return;
				}
				byte[] array = package.ReadByteArray();
				if (array.Length != num2 || array.Length > 320000)
				{
					_log.LogWarning((object)"Ignored an atlas share whose payload did not match its declared size.");
					return;
				}
				if (!AtlasCompression.TryDecompress(array, 4000000, out byte[] output))
				{
					_log.LogWarning((object)"Ignored an atlas share that was corrupt or decompressed beyond the safety cap.");
					return;
				}
				string[] array2 = Encoding.UTF8.GetString(output).Split(new char[1] { '\n' });
				if (array2.Length > 20000)
				{
					_log.LogWarning((object)"Ignored an atlas share with too many rows.");
					return;
				}
				List<string> list = new List<string>();
				List<string> list2 = new List<string>();
				List<string> list3 = null;
				string[] array3 = array2;
				for (int i = 0; i < array3.Length; i++)
				{
					string text3 = array3[i].TrimEnd(new char[1] { '\r' });
					if (text3 == "PINS")
					{
						list3 = list;
					}
					else if (text3 == "ROUTES")
					{
						list3 = list2;
					}
					else if (list3 != null && text3.Length > 0)
					{
						list3.Add(text3);
					}
				}
				PinCodec.ParseResult parseResult = PinCodec.Parse(list);
				RouteCodec.ParseResult parseResult2 = RouteCodec.Parse(list2);
				if (_inbox != null && (parseResult.Pins.Count != 0 || parseResult2.Routes.Count != 0))
				{
					_inbox.Add(new SyncInbox.Envelope(text, string.IsNullOrEmpty(text2) ? "Unknown Viking" : text2, parseResult.Pins, parseResult2.Routes, DateTime.UtcNow));
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Character)localPlayer).Message((MessageType)1, AtlasStrings.Format("hud.syncReceived", text2), 0, (Sprite)null);
					}
					_log.LogInfo((object)($"Atlas share received: {parseResult.Pins.Count} pin(s), {parseResult2.Routes.Count} route(s), " + $"{parseResult.MalformedRows + parseResult2.MalformedRows} malformed row(s) skipped."));
				}
			}
			catch (Exception exception)
			{
				_log.LogWarning((object)("Failed to read an atlas share: " + SafeLogText.Brief(exception)));
			}
		}

		private void Disable(Exception exception)
		{
			_disabledForSession = true;
			_log.LogError((object)("Sync transport failed and was disabled for this session: " + SafeLogText.Describe(exception)));
		}
	}
	internal static class WorldContext
	{
		public static bool TryGetWorldUid(out long uid)
		{
			uid = 0L;
			if (ZNet.instance == null)
			{
				return false;
			}
			uid = ZNet.instance.GetWorldUID();
			return uid != 0;
		}
	}
}
namespace TheConcernedCat.ConcernedCartographer.Persistence
{
	internal sealed class AtlasBackupTools
	{
		private readonly ManualLogSource _log;

		private static readonly string[] SidecarSuffixes = new string[3] { ".roads.tsv", ".pins.tsv", ".routes-atlas.tsv" };

		private static string DataDirectory => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer");

		private static string BackupRoot => Path.Combine(DataDirectory, "backups");

		public AtlasBackupTools(ManualLogSource log)
		{
			_log = log;
		}

		public string Backup(long worldUid, string label = "backup")
		{
			string arg = DateTime.UtcNow.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
			string text = Path.Combine(BackupRoot, $"{worldUid}-{arg}-{label}");
			Directory.CreateDirectory(text);
			int num = 0;
			string[] sidecarSuffixes = SidecarSuffixes;
			foreach (string text2 in sidecarSuffixes)
			{
				string text3 = Path.Combine(DataDirectory, worldUid.ToString(CultureInfo.InvariantCulture) + text2);
				if (File.Exists(text3))
				{
					File.Copy(text3, Path.Combine(text, Path.GetFileName(text3)), overwrite: true);
					num++;
				}
			}
			_log.LogInfo((object)$"Atlas backup: {num} file(s) copied into a new backup folder.");
			return text;
		}

		public List<string> ListBackups(long worldUid)
		{
			List<string> list = new List<string>();
			if (!Directory.Exists(BackupRoot))
			{
				return list;
			}
			string[] directories = Directory.GetDirectories(BackupRoot, worldUid.ToString(CultureInfo.InvariantCulture) + "-*");
			foreach (string item in directories)
			{
				list.Add(item);
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			list.Reverse();
			return list;
		}

		public string Restore(long worldUid, string backupPath)
		{
			if (!Directory.Exists(backupPath))
			{
				return "That backup no longer exists.";
			}
			Backup(worldUid, "pre-restore");
			int num = 0;
			string[] files = Directory.GetFiles(backupPath);
			foreach (string text in files)
			{
				string destFileName = Path.Combine(DataDirectory, Path.GetFileName(text));
				File.Copy(text, destFileName, overwrite: true);
				num++;
			}
			files = SidecarSuffixes;
			foreach (string text2 in files)
			{
				string path = Path.Combine(DataDirectory, worldUid.ToString(CultureInfo.InvariantCulture) + text2 + ".journal");
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			_log.LogInfo((object)$"Atlas restore: {num} file(s) restored from the chosen backup.");
			return $"Restored {num} file(s) from {Path.GetFileName(backupPath)} " + "(a pre-restore safety backup was taken). Log out and back in to load the restored atlas.";
		}

		public string WriteSupportReport(long worldUid, string pluginVersion, string effectiveConfig)
		{
			string text = Path.Combine(DataDirectory, "support-report.txt");
			List<(string, string)> list = new List<(string, string)>();
			string[] sidecarSuffixes = SidecarSuffixes;
			foreach (string text2 in sidecarSuffixes)
			{
				string text3 = Path.Combine(DataDirectory, worldUid.ToString(CultureInfo.InvariantCulture) + text2);
				if (!File.Exists(text3))
				{
					list.Add((text2, "absent"));
					continue;
				}
				try
				{
					list.Add((text2, SupportReportComposer.DescribeSidecar(text2, File.ReadAllLines(text3), new FileInfo(text3).Length)));
				}
				catch (Exception exception)
				{
					list.Add((text2, SupportReportComposer.UnreadableStatus(exception)));
				}
			}
			File.WriteAllLines(text, SupportReportComposer.Compose(DateTime.UtcNow, pluginVersion, effectiveConfig, list, ListBackups(worldUid).Count));
			return text;
		}
	}
	internal static class AuthorIdentity
	{
		private static string? _cached;

		public static string Get(ManualLogSource log)
		{
			if (_cached != null)
			{
				return _cached;
			}
			string path = Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", "author-id.txt");
			try
			{
				if (File.Exists(path))
				{
					string text = File.ReadAllText(path).Trim();
					if (Guid.TryParseExact(text, "N", out var _))
					{
						_cached = text;
						return text;
					}
				}
				string text2 = Guid.NewGuid().ToString("N");
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				File.WriteAllText(path, text2);
				_cached = text2;
				return text2;
			}
			catch (Exception exception)
			{
				log.LogWarning((object)("Could not persist an author identity; audit labels stay empty this session: " + SafeLogText.Brief(exception)));
				_cached = "";
				return "";
			}
		}
	}
	internal static class LocalizationPersistence
	{
		public static string OverridePath => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", "cartographer-strings.tsv");

		public static string TemplatePath => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", "cartographer-strings-template.tsv");

		public static void Initialize(ManualLogSource log)
		{
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(TemplatePath));
				File.WriteAllLines(TemplatePath, AtlasStrings.TranslatorTemplate());
				if (File.Exists(OverridePath))
				{
					int skippedRows;
					Dictionary<string, string> dictionary = AtlasStrings.ParseOverrides(File.ReadAllLines(OverridePath), out skippedRows);
					AtlasStrings.LoadOverrides(dictionary);
					log.LogInfo((object)($"Loaded {dictionary.Count} translated string(s) from cartographer-strings.tsv" + ((skippedRows > 0) ? $" ({skippedRows} row(s) skipped)." : ".")));
				}
			}
			catch (Exception exception)
			{
				log.LogWarning((object)("Localization stayed at English defaults: " + SafeLogText.Brief(exception)));
			}
		}
	}
	internal sealed class PinPersistence
	{
		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		private readonly List<string> _pendingJournalRows = new List<string>();

		private long _journalWorldUid;

		public PinPersistence(ManualLogSource log)
		{
			_log = log;
			_rateLimited = new RateLimitedLog(log, 60f);
		}

		public PinStore Load(long worldUid)
		{
			_pendingJournalRows.Clear();
			_journalWorldUid = worldUid;
			string snapshotPath = GetSnapshotPath(worldUid);
			string journalPath = GetJournalPath(worldUid);
			try
			{
				List<string> list = new List<string>();
				if (File.Exists(snapshotPath))
				{
					list.AddRange(File.ReadAllLines(snapshotPath));
				}
				bool flag = false;
				if (File.Exists(journalPath))
				{
					list.AddRange(File.ReadAllLines(journalPath));
					flag = true;
				}
				PinCodec.ParseResult parseResult = PinCodec.Parse(list);
				if (parseResult.MalformedRows > 0)
				{
					_log.LogWarning((object)$"Skipped {parseResult.MalformedRows} malformed pin row(s) for this world.");
				}
				PinStore pinStore = new PinStore(parseResult.Pins);
				if (flag)
				{
					_log.LogInfo((object)($"Recovered pin journal for this world: {parseResult.Pins.Count} pin(s) after replay " + $"({parseResult.SupersededRows} superseded row(s)); compacting into a fresh snapshot."));
					Save(worldUid, pinStore, force: true);
				}
				return pinStore;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not load pins for this world: " + SafeLogText.Describe(exception)));
				return new PinStore();
			}
		}

		public void QueueJournal(AtlasPin pin)
		{
			_pendingJournalRows.Add(PinCodec.SerializeRow(pin));
		}

		public void FlushJournal()
		{
			if (_pendingJournalRows.Count == 0)
			{
				return;
			}
			string journalPath = GetJournalPath(_journalWorldUid);
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(journalPath));
				File.AppendAllLines(journalPath, _pendingJournalRows);
				_pendingJournalRows.Clear();
			}
			catch (Exception exception)
			{
				_rateLimited.Error("pin-journal", "Could not append the pin journal for this world: " + SafeLogText.Describe(exception));
			}
		}

		public bool Save(long worldUid, PinStore store, bool force = false)
		{
			if (!force && !store.IsDirty)
			{
				return false;
			}
			string snapshotPath = GetSnapshotPath(worldUid);
			string text = snapshotPath + ".tmp";
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(snapshotPath));
				using (StreamWriter streamWriter = new StreamWriter(text, append: false))
				{
					foreach (string item in PinCodec.Serialize(store.All))
					{
						streamWriter.WriteLine(item);
					}
				}
				File.Copy(text, snapshotPath, overwrite: true);
				File.Delete(text);
				_pendingJournalRows.Clear();
				TryDelete(GetJournalPath(worldUid));
				store.MarkClean();
				return true;
			}
			catch (Exception exception)
			{
				_rateLimited.Error("pin-save", "Could not save pins for this world: " + SafeLogText.Describe(exception));
				TryDelete(text);
				return false;
			}
		}

		private static string GetSnapshotPath(long worldUid)
		{
			return Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", worldUid.ToString(CultureInfo.InvariantCulture) + ".pins.tsv");
		}

		private static string GetJournalPath(long worldUid)
		{
			return GetSnapshotPath(worldUid) + ".journal";
		}

		private static void TryDelete(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class RoadPersistence
	{
		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		private readonly HashSet<string> _legacyPathsAwaitingBackup = new HashSet<string>();

		private readonly HashSet<long> _reconcileBackupsTaken = new HashSet<long>();

		public RoadPersistence(ManualLogSource log)
		{
			_log = log;
			_rateLimited = new RateLimitedLog(log, 60f);
		}

		public RoadAtlas Load(long worldUid)
		{
			string path = GetPath(worldUid);
			if (!File.Exists(path))
			{
				return new RoadAtlas();
			}
			try
			{
				RoadAtlasCodec.ParseResult parseResult = RoadAtlasCodec.Parse(File.ReadLines(path));
				if (parseResult.MalformedRows > 0)
				{
					_log.LogWarning((object)$"Skipped {parseResult.MalformedRows} malformed road-atlas row(s) in this world's sidecar.");
				}
				if (parseResult.LegacyRows > 0)
				{
					_legacyPathsAwaitingBackup.Add(path);
					_log.LogInfo((object)($"This world's road atlas uses the v1 format ({parseResult.LegacyRows} row(s)); " + "the original will be kept as .v1.bak when it is first rewritten in v2."));
				}
				RoadAtlas roadAtlas = new RoadAtlas(parseResult.Strokes);
				RoadAtlas.MigrationResult migrationResult = roadAtlas.RemoveNonConstructionStrokes();
				if (migrationResult.RemovedStrokes > 0)
				{
					TakeAuthorityMigrationBackup(path);
					_log.LogInfo((object)($"Road source authority (v1): removed {migrationResult.RemovedStrokes} passive stroke(s) " + $"({migrationResult.RemovedPoints} point(s)) recorded by traversal/chunk recovery; " + $"{roadAtlas.Strokes.Count} explicit construction stroke(s) remain. " + "The pre-migration file was kept as .pre-authority.bak."));
				}
				RoadAtlas.MaintenanceResult maintenanceResult = roadAtlas.PerformMaintenance();
				if (maintenanceResult.MergedStrokes > 0 || maintenanceResult.RemovedPoints > 0)
				{
					_log.LogInfo((object)($"Road atlas maintenance: merged {maintenanceResult.MergedStrokes} stroke fragment(s), " + $"simplified away {maintenanceResult.RemovedPoints} point(s); {roadAtlas.Strokes.Count} stroke(s), " + $"{roadAtlas.PointCount} point(s) remain."));
				}
				return roadAtlas;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not load road atlas from disk: " + SafeLogText.Describe(exception)));
				return new RoadAtlas();
			}
		}

		public bool Save(long worldUid, RoadAtlas atlas)
		{
			string path = GetPath(worldUid);
			string text = path + ".tmp";
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				if (_legacyPathsAwaitingBackup.Contains(path) && File.Exists(path))
				{
					string text2 = path + ".v1.bak";
					if (!File.Exists(text2))
					{
						File.Copy(path, text2);
						_log.LogInfo((object)"Backed up the v1 road atlas beside its sidecar (.v1.bak) before the first v2 save.");
					}
					_legacyPathsAwaitingBackup.Remove(path);
				}
				using (StreamWriter streamWriter = new StreamWriter(text, append: false))
				{
					foreach (string item in RoadAtlasCodec.Serialize(atlas.Strokes))
					{
						streamWriter.WriteLine(item);
					}
				}
				File.Copy(text, path, overwrite: true);
				File.Delete(text);
				return true;
			}
			catch (Exception exception)
			{
				_rateLimited.Error("atlas-save", "Could not save road atlas to disk: " + SafeLogText.Describe(exception));
				TryDelete(text);
				return false;
			}
		}

		private void TakeAuthorityMigrationBackup(string path)
		{
			try
			{
				string text = path + ".pre-authority.bak";
				if (File.Exists(path) && !File.Exists(text))
				{
					File.Copy(path, text);
					_log.LogInfo((object)"Backed up the pre-migration road atlas beside its sidecar (.pre-authority.bak).");
				}
			}
			catch (Exception exception)
			{
				_rateLimited.Error("authority-backup", "Could not back up the road atlas before the authority migration: " + SafeLogText.Describe(exception));
			}
		}

		public void BackupBeforeReconciliation(long worldUid)
		{
			if (!_reconcileBackupsTaken.Add(worldUid))
			{
				return;
			}
			try
			{
				string path = GetPath(worldUid);
				if (File.Exists(path))
				{
					File.Copy(path, path + ".pre-reconcile.bak", overwrite: true);
					_log.LogInfo((object)"Backed up the road atlas beside its sidecar (.pre-reconcile.bak) before this session's first reconciliation.");
				}
			}
			catch (Exception exception)
			{
				_rateLimited.Error("reconcile-backup", "Could not back up the road atlas before reconciliation: " + SafeLogText.Describe(exception));
			}
		}

		private static string GetPath(long worldUid)
		{
			return Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", worldUid.ToString(CultureInfo.InvariantCulture) + ".roads.tsv");
		}

		private static void TryDelete(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class RoutePersistence
	{
		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		private readonly Dictionary<Guid, AtlasRoute> _pendingJournal = new Dictionary<Guid, AtlasRoute>();

		private long _journalWorldUid;

		public RoutePersistence(ManualLogSource log)
		{
			_log = log;
			_rateLimited = new RateLimitedLog(log, 60f);
		}

		public RouteStore Load(long worldUid)
		{
			_pendingJournal.Clear();
			_journalWorldUid = worldUid;
			string snapshotPath = GetSnapshotPath(worldUid);
			string journalPath = GetJournalPath(worldUid);
			try
			{
				List<string> list = new List<string>();
				if (File.Exists(snapshotPath))
				{
					list.AddRange(File.ReadAllLines(snapshotPath));
				}
				bool flag = false;
				if (File.Exists(journalPath))
				{
					list.AddRange(File.ReadAllLines(journalPath));
					flag = true;
				}
				RouteCodec.ParseResult parseResult = RouteCodec.Parse(list);
				if (parseResult.MalformedRows > 0)
				{
					_log.LogWarning((object)$"Skipped {parseResult.MalformedRows} malformed route row(s) for this world.");
				}
				RouteStore routeStore = new RouteStore(parseResult.Routes);
				if (flag)
				{
					_log.LogInfo((object)$"Recovered route journal for this world: {parseResult.Routes.Count} route(s) after replay.");
					Save(worldUid, routeStore, force: true);
				}
				return routeStore;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not load routes for this world: " + SafeLogText.Describe(exception)));
				return new RouteStore();
			}
		}

		public void QueueJournal(AtlasRoute route)
		{
			_pendingJournal[route.Id.Value] = route;
		}

		public void FlushJournal()
		{
			if (_pendingJournal.Count == 0)
			{
				return;
			}
			string journalPath = GetJournalPath(_journalWorldUid);
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(journalPath));
				List<string> list = new List<string>();
				foreach (AtlasRoute value in _pendingJournal.Values)
				{
					list.AddRange(RouteCodec.SerializeRoute(value));
				}
				File.AppendAllLines(journalPath, list);
				_pendingJournal.Clear();
			}
			catch (Exception exception)
			{
				_rateLimited.Error("route-journal", "Could not append the route journal: " + SafeLogText.Describe(exception));
			}
		}

		public bool Save(long worldUid, RouteStore store, bool force = false)
		{
			if (!force && !store.IsDirty)
			{
				return false;
			}
			string snapshotPath = GetSnapshotPath(worldUid);
			string text = snapshotPath + ".tmp";
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(snapshotPath));
				using (StreamWriter streamWriter = new StreamWriter(text, append: false))
				{
					foreach (string item in RouteCodec.Serialize(store.All))
					{
						streamWriter.WriteLine(item);
					}
				}
				File.Copy(text, snapshotPath, overwrite: true);
				File.Delete(text);
				_pendingJournal.Clear();
				TryDelete(GetJournalPath(worldUid));
				store.MarkClean();
				return true;
			}
			catch (Exception exception)
			{
				_rateLimited.Error("route-save", "Could not save routes for this world: " + SafeLogText.Describe(exception));
				TryDelete(text);
				return false;
			}
		}

		private static string GetSnapshotPath(long worldUid)
		{
			return Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", worldUid.ToString(CultureInfo.InvariantCulture) + ".routes-atlas.tsv");
		}

		private static string GetJournalPath(long worldUid)
		{
			return GetSnapshotPath(worldUid) + ".journal";
		}

		private static void TryDelete(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class SavedViewPersistence
	{
		private readonly ManualLogSource _log;

		public SavedViewPersistence(ManualLogSource log)
		{
			_log = log;
		}

		public SavedViewStore Load()
		{
			string path = GetPath();
			try
			{
				if (!File.Exists(path))
				{
					return new SavedViewStore();
				}
				int malformedRows;
				SavedViewStore result = SavedViewStore.Parse(File.ReadAllLines(path), out malformedRows);
				if (malformedRows > 0)
				{
					_log.LogWarning((object)$"Skipped {malformedRows} malformed saved-view row(s) in the saved-views file.");
				}
				return result;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not load saved views: " + SafeLogText.Describe(exception)));
				return new SavedViewStore();
			}
		}

		public void Save(SavedViewStore store)
		{
			if (!store.IsDirty)
			{
				return;
			}
			string path = GetPath();
			string text = path + ".tmp";
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				File.WriteAllLines(text, store.Serialize());
				File.Copy(text, path, overwrite: true);
				File.Delete(text);
				store.MarkClean();
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not save views: " + SafeLogText.Describe(exception)));
			}
		}

		private static string GetPath()
		{
			return Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", "views.tsv");
		}
	}
	internal sealed class SurveyRejectedPersistence
	{
		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		public SurveyRejectedPersistence(ManualLogSource log)
		{
			_log = log;
			_rateLimited = new RateLimitedLog(log, 60f);
		}

		public List<SurveyEngine.RejectedObservation> Load(long worldUid)
		{
			string path = GetPath(worldUid);
			if (!File.Exists(path))
			{
				return new List<SurveyEngine.RejectedObservation>();
			}
			try
			{
				int malformedRows;
				List<SurveyEngine.RejectedObservation> result = SurveyRejectedCodec.Parse(File.ReadLines(path), out malformedRows);
				if (malformedRows > 0)
				{
					_log.LogWarning((object)$"Skipped {malformedRows} malformed rejected-survey row(s) in this world's sidecar.");
				}
				return result;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not load the rejected-survey list from disk: " + SafeLogText.Describe(exception)));
				return new List<SurveyEngine.RejectedObservation>();
			}
		}

		public bool Save(long worldUid, IEnumerable<SurveyEngine.RejectedObservation> entries)
		{
			string path = GetPath(worldUid);
			string text = path + ".tmp";
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				File.WriteAllLines(text, SurveyRejectedCodec.Serialize(entries));
				File.Copy(text, path, overwrite: true);
				File.Delete(text);
				return true;
			}
			catch (Exception exception)
			{
				_rateLimited.Error("survey-rejected-save", "Could not save the rejected-survey list to disk: " + SafeLogText.Describe(exception));
				return false;
			}
		}

		private static string GetPath(long worldUid)
		{
			return Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", worldUid.ToString(CultureInfo.InvariantCulture) + ".survey-rejected.tsv");
		}
	}
	internal sealed class SurveyRulePersistence
	{
		private readonly ManualLogSource _log;

		public static string RulePath => Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", "survey-rules.tsv");

		public SurveyRulePersistence(ManualLogSource log)
		{
			_log = log;
		}

		public SurveyRuleSet LoadOrCreate()
		{
			try
			{
				if (!File.Exists(RulePath))
				{
					Directory.CreateDirectory(Path.GetDirectoryName(RulePath));
					File.WriteAllLines(RulePath, SurveyRuleSet.Default().Serialize());
					_log.LogInfo((object)"Wrote the starter survey rules to survey-rules.tsv.");
				}
				else
				{
					string text = Normalize(File.ReadAllLines(RulePath));
					if (text == Normalize(SurveyRuleSet.LegacyStarterSet().Serialize()) || text == Normalize(SurveyRuleSet.Rc8StarterSet().Serialize()))
					{
						File.WriteAllLines(RulePath, SurveyRuleSet.Default().Serialize());
						_log.LogInfo((object)"Upgraded the untouched starter survey rules (survey-rules.tsv) to the v1 starter set (edited files are never touched).");
					}
				}
				int malformedRows;
				SurveyRuleSet result = SurveyRuleSet.Parse(File.ReadAllLines(RulePath), out malformedRows);
				if (malformedRows > 0)
				{
					_log.LogWarning((object)$"Skipped {malformedRows} malformed survey rule(s) in survey-rules.tsv.");
				}
				return result;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not load survey rules; the survey stays inactive: " + SafeLogText.Describe(exception)));
				return new SurveyRuleSet();
			}
		}

		public bool Save(SurveyRuleSet rules)
		{
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(RulePath));
				File.WriteAllLines(RulePath, rules.Serialize());
				return true;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not save the survey rules to disk: " + SafeLogText.Describe(exception)));
				return false;
			}
		}

		private static string Normalize(IEnumerable<string> lines)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string line in lines)
			{
				stringBuilder.Append(line.TrimEnd(Array.Empty<char>())).Append('\n');
			}
			return stringBuilder.ToString();
		}
	}
	internal sealed class TerrainIntentPersistence
	{
		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		public TerrainIntentPersistence(ManualLogSource log)
		{
			_log = log;
			_rateLimited = new RateLimitedLog(log, 60f);
		}

		public TerrainIntentMask Load(long worldUid)
		{
			string path = GetPath(worldUid);
			if (!File.Exists(path))
			{
				return new TerrainIntentMask();
			}
			try
			{
				TerrainIntentCodec.ParseResult parseResult = TerrainIntentCodec.Parse(File.ReadLines(path));
				if (parseResult.UnsupportedVersion)
				{
					_log.LogWarning((object)"This world's terrain-intent sidecar has an unsupported header (written by a newer version?); starting with no exclusions for this session. The file is rewritten in v1 on the next save.");
				}
				else if (parseResult.MalformedRows > 0)
				{
					_log.LogWarning((object)$"Skipped {parseResult.MalformedRows} malformed terrain-intent row(s) in this world's sidecar.");
				}
				return parseResult.Mask;
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not load terrain intent from disk: " + SafeLogText.Describe(exception)));
				return new TerrainIntentMask();
			}
		}

		public bool Save(long worldUid, TerrainIntentMask mask)
		{
			string path = GetPath(worldUid);
			string text = path + ".tmp";
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				using (StreamWriter streamWriter = new StreamWriter(text, append: false))
				{
					foreach (string item in TerrainIntentCodec.Serialize(mask))
					{
						streamWriter.WriteLine(item);
					}
				}
				File.Copy(text, path, overwrite: true);
				File.Delete(text);
				return true;
			}
			catch (Exception exception)
			{
				_rateLimited.Error("terrain-intent-save", "Could not save terrain intent to disk: " + SafeLogText.Describe(exception));
				TryDelete(text);
				return false;
			}
		}

		private static string GetPath(long worldUid)
		{
			return Path.Combine(Paths.ConfigPath, "ConcernedCatMods", "ConcernedCartographer", worldUid.ToString(CultureInfo.InvariantCulture) + ".terrain-intent.tsv");
		}

		private static void TryDelete(string path)
		{
			try
			{
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}
	}
}
namespace TheConcernedCat.ConcernedCartographer.Map
{
	internal sealed class AtlasDrawerPanel
	{
		private const int ResultSlots = 5;

		private const int ViewSlots = 4;

		private const float PanelWidth = 380f;

		private const float PanelHeight = 700f;

		private const float EdgePadding = 22f;

		private const float ContentWidth = 336f;

		private const float LeftEdge = -168f;

		private const float ToggleLabelWidth = 210f;

		private const float ColumnGap = 8f;

		private const float ActionButtonWidth = 56f;

		private const float RowHeight = 28f;

		private const float ClearButtonWidth = 120f;

		private readonly ManualLogSource _log;

		public Func<string>? LoadPosition;

		public Action<string>? PositionCaptured;

		public Action<bool>? DirtToggled;

		public Action<bool>? PavedToggled;

		public Action<bool>? PinsToggled;

		public Action<bool>? ClusterToggled;

		public Action<string>? QueryApplied;

		public Action<string>? ViewSaved;

		public Action<string>? ViewApplied;

		public Action<AtlasId>? ResultClicked;

		public Action? PrivacyClicked;

		public Action? SystemMarkersClicked;

		public Func<string>? StatusLine;

		public Func<List<(string Label, AtlasId Id)>>? TopResults;

		public Func<List<string>>? ViewNames;

		private GameObject? _panel;

		private Toggle? _dirt;

		private Toggle? _paved;

		private Toggle? _pins;

		private Toggle? _cluster;

		private InputField? _query;

		private InputField? _viewName;

		private Text? _status;

		private readonly Button[] _resultButtons = (Button[])(object)new Button[5];

		private readonly Text[] _resultLabels = (Text[])(object)new Text[5];

		private readonly AtlasId[] _resultIds = new AtlasId[5];

		private readonly Button[] _viewButtons = (Button[])(object)new Button[4];

		private readonly Text[] _viewLabels = (Text[])(object)new Text[4];

		private bool _failed;

		private bool _suppressToggleEvents;

		private bool _hasLivePosition;

		private float _liveX;

		private float _liveY;

		private float _openedAtX;

		private float _openedAtY;

		public float UiScale = 1f;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public bool HasFailed => _failed;

		public AtlasDrawerPanel(ManualLogSource log)
		{
			_log = log;
		}

		public void Toggle(bool showDirt, bool showPaved, bool showPins, bool cluster)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (IsVisible)
			{
				Hide();
			}
			else
			{
				if (!EnsureBuilt())
				{
					return;
				}
				try
				{
					_suppressToggleEvents = true;
					_dirt.isOn = showDirt;
					_paved.isOn = showPaved;
					_pins.isOn = showPins;
					_cluster.isOn = cluster;
					_suppressToggleEvents = false;
					RefreshLists();
					_panel.transform.localScale = Vector3.one * UiScale;
					Vector2 val = ResolveOpenPosition();
					((RectTransform)_panel.transform).anchoredPosition = val;
					_openedAtX = val.x;
					_openedAtY = val.y;
					_panel.SetActive(true);
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Object)(object)_dirt != (Object)null) ? ((Component)_dirt).gameObject : null);
					}
				}
				catch (Exception exception)
				{
					Fail(exception);
				}
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				NotePosition();
				_panel.SetActive(false);
			}
			FlushPosition();
		}

		public void FlushPosition()
		{
			if (_hasLivePosition)
			{
				_hasLivePosition = false;
				PositionCaptured?.Invoke(PanelPositionRule.Serialize(_liveX, _liveY));
			}
		}

		private Vector2 ResolveOpenPosition()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			Vector2 result = default(Vector2);
			((Vector2)(ref result))..ctor(0f - 380f * UiScale / 2f - 30f, 0f);
			if (!PanelPositionRule.TryParse(LoadPosition?.Invoke(), out var x, out var y))
			{
				return result;
			}
			RectTransform val = (RectTransform)(((Object)(object)GUIManager.CustomGUIFront != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)val == (Object)null)
			{
				return result;
			}
			float x2 = x;
			float y2 = y;
			float uiScale = UiScale;
			Rect rect = val.rect;
			float width = ((Rect)(ref rect)).width;
			rect = val.rect;
			var (num, num2) = PanelPositionRule.Clamp(x2, y2, 380f, 700f, uiScale, width, ((Rect)(ref rect)).height);
			return new Vector2(num, num2);
		}

		private void NotePosition()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_panel == (Object)null))
			{
				Vector2 anchoredPosition = ((RectTransform)_panel.transform).anchoredPosition;
				_liveX = anchoredPosition.x;
				_liveY = anchoredPosition.y;
				if (Mathf.Abs(anchoredPosition.x - _openedAtX) > 0.5f || Mathf.Abs(anchoredPosition.y - _openedAtY) > 0.5f)
				{
					_hasLivePosition = true;
				}
			}
		}

		public void RefreshLists()
		{
			if (!IsVisible && (Object)(object)_panel == (Object)null)
			{
				return;
			}
			try
			{
				_status.text = StatusLine?.Invoke() ?? "";
				List<(string, AtlasId)> list = TopResults?.Invoke() ?? new List<(string, AtlasId)>();
				for (int i = 0; i < 5; i++)
				{
					bool flag = i < list.Count;
					((Component)_resultButtons[i]).gameObject.SetActive(flag);
					if (flag)
					{
						_resultLabels[i].text = Truncate(list[i].Item1, 30);
						_resultIds[i] = list[i].Item2;
					}
				}
				List<string> list2 = ViewNames?.Invoke() ?? new List<string>();
				for (int j = 0; j < 4; j++)
				{
					bool flag2 = j < list2.Count;
					((Component)_viewButtons[j]).gameObject.SetActive(flag2);
					if (flag2)
					{
						_viewLabels[j].text = Truncate(list2[j], 26);
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void HandleFrame()
		{
			if (IsVisible)
			{
				NotePosition();
				if (Input.GetKeyDown((KeyCode)27) && !CcTextFocus.EscapeShouldOnlyBlur())
				{
					Hide();
				}
			}
		}

		private bool EnsureBuilt()
		{
			if (_failed)
			{
				return false;
			}
			if ((Object)(object)_panel != (Object)null)
			{
				return true;
			}
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				_log.LogWarning((object)"Atlas drawer UI is unavailable (no GUI root yet); use the cc_atlas console instead.");
				return false;
			}
			try
			{
				Build();
				return (Object)(object)_panel != (Object)null;
			}
			catch (Exception exception)
			{
				Fail(exception);
				return false;
			}
		}

		private void Build()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Expected O, but got Unknown
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Expected O, but got Unknown
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Expected O, but got Unknown
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Expected O, but got Unknown
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0709: Expected O, but got Unknown
			//IL_0729: Unknown result type (might be due to invalid IL or missing references)
			//IL_0738: Unknown result type (might be due to invalid IL or missing references)
			//IL_0759: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0785: Expected O, but got Unknown
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color val = default(Color);
			((Color)(ref val))..ctor(0.9f, 0.8f, 0.6f, 1f);
			_panel = instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-220f, 0f), 380f, 700f, true);
			instance.CreateText(AtlasStrings.Get("drawer.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 20, val, true, Color.black, 336f, 30f, false);
			float y = -62f;
			AddSectionHeader(instance, averiaSerifBold, val, AtlasStrings.Get("drawer.layers"), ref y);
			_dirt = CreateToggleRow(instance, averiaSerifBold, AtlasStrings.Get("drawer.dirtRoads"), ref y, delegate(bool value)
			{
				if (!_suppressToggleEvents)
				{
					DirtToggled?.Invoke(value);
				}
			});
			_paved = CreateToggleRow(instance, averiaSerifBold, AtlasStrings.Get("drawer.pavedRoads"), ref y, delegate(bool value)
			{
				if (!_suppressToggleEvents)
				{
					PavedToggled?.Invoke(value);
				}
			});
			_pins = CreateToggleRow(instance, averiaSerifBold, AtlasStrings.Get("drawer.pins"), ref y, delegate(bool value)
			{
				if (!_suppressToggleEvents)
				{
					PinsToggled?.Invoke(value);
					RefreshLists();
				}
			});
			_cluster = CreateToggleRow(instance, averiaSerifBold, AtlasStrings.Get("drawer.clustering"), ref y, delegate(bool value)
			{
				if (!_suppressToggleEvents)
				{
					ClusterToggled?.Invoke(value);
					RefreshLists();
				}
			});
			y -= 6f;
			AddSectionHeader(instance, averiaSerifBold, val, AtlasStrings.Get("drawer.search"), ref y);
			float num = 272f;
			_query = instance.CreateInputField(_panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-168f + num / 2f, y), (ContentType)0, "name, tag:iron, near:…", 13, num, 28f).GetComponent<InputField>();
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("drawer.go"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-168f + num + 8f + 28f, y), 56f, 28f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				QueryApplied?.Invoke(_query.text);
				RefreshLists();
			});
			y -= 32f;
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("drawer.clearFilter"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-108f, y), 120f, 26f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				_query.text = "";
				QueryApplied?.Invoke("");
				RefreshLists();
			});
			float num2 = 208f;
			_status = instance.CreateText("", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-40f + num2 / 2f, y), averiaSerifBold, 11, Color.white, false, Color.black, num2, 26f, false).GetComponent<Text>();
			_status.alignment = (TextAnchor)3;
			_status.horizontalOverflow = (HorizontalWrapMode)0;
			_status.verticalOverflow = (VerticalWrapMode)0;
			y -= 30f;
			for (int num3 = 0; num3 < 5; num3++)
			{
				int captured = num3;
				GameObject val2 = instance.CreateButton("", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), 336f, 26f);
				_resultButtons[num3] = val2.GetComponent<Button>();
				_resultLabels[num3] = val2.GetComponentInChildren<Text>();
				((UnityEvent)_resultButtons[num3].onClick).AddListener((UnityAction)delegate
				{
					ResultClicked?.Invoke(_resultIds[captured]);
				});
				val2.SetActive(false);
				y -= 28f;
			}
			y -= 6f;
			AddSectionHeader(instance, averiaSerifBold, val, AtlasStrings.Get("drawer.views"), ref y);
			_viewName = instance.CreateInputField(_panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-168f + num / 2f, y), (ContentType)0, "view name", 13, num, 28f).GetComponent<InputField>();
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("drawer.save"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-168f + num + 8f + 28f, y), 56f, 28f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				if (_viewName.text.Trim().Length > 0)
				{
					ViewSaved?.Invoke(_viewName.text.Trim());
					RefreshLists();
				}
			});
			y -= 32f;
			for (int num4 = 0; num4 < 4; num4++)
			{
				int captured2 = num4;
				GameObject val3 = instance.CreateButton("", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), 336f, 26f);
				_viewButtons[num4] = val3.GetComponent<Button>();
				_viewLabels[num4] = val3.GetComponentInChildren<Text>();
				((UnityEvent)_viewButtons[num4].onClick).AddListener((UnityAction)delegate
				{
					ViewApplied?.Invoke(_viewLabels[captured2].text);
					RefreshLists();
				});
				val3.SetActive(false);
				y -= 28f;
			}
			instance.CreateText(AtlasStrings.Get("drawer.placeholders"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 24f), averiaSerifBold, 11, new Color(1f, 1f, 1f, 0.6f), false, Color.black, 336f, 22f, false);
			float num5 = 164f;
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("drawer.privacy"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-168f + num5 / 2f, 52f), num5, 26f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				PrivacyClicked?.Invoke();
			});
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("system.title"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-168f + num5 + 8f + num5 / 2f, 52f), num5, 26f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				SystemMarkersClicked?.Invoke();
			});
			_panel.SetActive(false);
		}

		private void AddSectionHeader(GUIManager gui, Font font, Color color, string text, ref float y)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			gui.CreateText(text, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), font, 15, color, false, Color.black, 336f, 24f, false).GetComponent<Text>().alignment = (TextAnchor)3;
			y -= 28f;
		}

		private Toggle CreateToggleRow(GUIManager gui, Font font, string label, ref float y, Action<bool> changed)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			gui.CreateText(label, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-63f, y), font, 13, Color.white, false, Color.black, 210f, 24f, false).GetComponent<Text>().alignment = (TextAnchor)3;
			GameObject obj = gui.CreateToggle(_panel.transform, 26f, 26f);
			RectTransform val = (RectTransform)obj.transform;
			val.anchorMin = new Vector2(0.5f, 1f);
			val.anchorMax = new Vector2(0.5f, 1f);
			val.anchoredPosition = new Vector2(63f, y);
			Toggle componentInChildren = obj.GetComponentInChildren<Toggle>();
			((UnityEvent<bool>)(object)componentInChildren.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
			{
				changed(value);
			});
			y -= 28f;
			return componentInChildren;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			_log.LogError((object)("Atlas drawer failed and was disabled for this session (cc_atlas console remains available): " + SafeLogText.Describe(exception)));
		}

		private static string Truncate(string text, int max)
		{
			if (text.Length > max)
			{
				return text.Substring(0, max) + "…";
			}
			return text;
		}
	}
	internal static class CcIconSprites
	{
		private const string ResourcePrefix = "CC.Icons.";

		private static readonly Dictionary<string, Sprite> Cache = new Dictionary<string, Sprite>();

		private static readonly HashSet<string> Failed = new HashSet<string>();

		public static void ResetSession()
		{
			Failed.Clear();
		}

		public static bool TryGet(string? iconId, out Sprite sprite)
		{
			sprite = null;
			if (string.IsNullOrEmpty(iconId) || !IconRegistry.TryResolve(iconId, out IconRegistry.IconDefinition definition) || !definition.HasCustomSprite)
			{
				return false;
			}
			string spriteKey = definition.SpriteKey;
			if (Failed.Contains(spriteKey))
			{
				return false;
			}
			if (Cache.TryGetValue(spriteKey, out Sprite value) && (Object)(object)value != (Object)null)
			{
				sprite = value;
				return true;
			}
			Sprite val = Load(spriteKey);
			if ((Object)(object)val == (Object)null)
			{
				Failed.Add(spriteKey);
				return false;
			}
			Cache[spriteKey] = val;
			sprite = val;
			return true;
		}

		private static Sprite? Load(string key)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			try
			{
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("CC.Icons." + key + ".png");
				if (stream == null)
				{
					return null;
				}
				using MemoryStream memoryStream = new MemoryStream();
				stream.CopyTo(memoryStream);
				if (!TryDecodePng(memoryStream.ToArray(), out int width, out int height, out Color32[] pixels))
				{
					return null;
				}
				Texture2D val = new Texture2D(width, height, (TextureFormat)4, false)
				{
					name = "CCIcon_" + key,
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1,
					hideFlags = (HideFlags)32
				};
				val.SetPixels32(pixels);
				val.Apply(false, true);
				Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)width, (float)height), new Vector2(0.5f, 0.5f), 100f);
				((Object)obj).name = "CCIcon_" + key;
				((Object)obj).hideFlags = (HideFlags)32;
				return obj;
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static bool TryDecodePng(byte[] data, out int width, out int height, out Color32[] pixels)
		{
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			width = 0;
			height = 0;
			pixels = null;
			if (data.Length < 8 || data[0] != 137 || data[1] != 80 || data[2] != 78 || data[3] != 71)
			{
				return false;
			}
			using MemoryStream memoryStream = new MemoryStream();
			int num2;
			int num3;
			for (int num = 8; num + 8 <= data.Length; num = num3 + num2 + 4)
			{
				num2 = ReadBigEndianInt(data, num);
				string text = Encoding.ASCII.GetString(data, num + 4, 4);
				num3 = num + 8;
				if (num2 < 0 || num3 + num2 > data.Length)
				{
					return false;
				}
				switch (text)
				{
				case "IHDR":
				{
					width = ReadBigEndianInt(data, num3);
					height = ReadBigEndianInt(data, num3 + 4);
					byte num4 = data[num3 + 8];
					byte b = data[num3 + 9];
					byte b2 = data[num3 + 12];
					if (num4 == 8 && b == 6 && b2 == 0)
					{
						continue;
					}
					return false;
				}
				case "IDAT":
					memoryStream.Write(data, num3, num2);
					continue;
				default:
					continue;
				case "IEND":
					break;
				}
				break;
			}
			if (width <= 0 || height <= 0 || width > 512 || height > 512 || memoryStream.Length < 6)
			{
				return false;
			}
			memoryStream.Position = 2L;
			byte[] array = new byte[(width * 4 + 1) * height];
			using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionMode.Decompress, leaveOpen: true))
			{
				int num5;
				for (int i = 0; i < array.Length; i += num5)
				{
					num5 = deflateStream.Read(array, i, array.Length - i);
					if (num5 <= 0)
					{
						return false;
					}
				}
			}
			pixels = (Color32[])(object)new Color32[width * height];
			int num6 = width * 4 + 1;
			for (int j = 0; j < height; j++)
			{
				if (array[j * num6] != 0)
				{
					return false;
				}
				int num7 = (height - 1 - j) * width;
				int num8 = j * num6 + 1;
				for (int k = 0; k < width; k++)
				{
					pixels[num7 + k] = new Color32(array[num8 + k * 4], array[num8 + k * 4 + 1], array[num8 + k * 4 + 2], array[num8 + k * 4 + 3]);
				}
			}
			return true;
		}

		private static int ReadBigEndianInt(byte[] data, int offset)
		{
			return (data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3];
		}
	}
	internal abstract class CcSidePanel
	{
		protected const float DockMargin = 30f;

		protected readonly ManualLogSource Log;

		private readonly string _titleKey;

		private readonly float _width;

		private readonly float _height;

		private GameObject? _panel;

		private Text? _title;

		private bool _failed;

		public float UiScale = 1f;

		private float _appliedScale = 1f;

		private bool _suppressToggleEvents;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public bool HasFailed => _failed;

		protected float Width => _width;

		protected float Height => _height;

		protected GameObject? Panel => _panel;

		protected CcSidePanel(ManualLogSource log, string titleKey, float width, float height)
		{
			Log = log;
			_titleKey = titleKey;
			_width = width;
			_height = height;
		}

		public void Show()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!EnsureBuilt())
			{
				return;
			}
			try
			{
				if (!Mathf.Approximately(_appliedScale, UiScale))
				{
					_appliedScale = UiScale;
					_panel.transform.localScale = Vector3.one * UiScale;
					((RectTransform)_panel.transform).anchoredPosition = DockPosition(UiScale);
				}
				_panel.SetActive(true);
				OnShown();
				Selectable componentInChildren = _panel.GetComponentInChildren<Selectable>(false);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Component)componentInChildren).gameObject);
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
				try
				{
					OnHidden();
				}
				catch (Exception exception)
				{
					Fail(exception);
				}
			}
		}

		public void Toggle()
		{
			if (IsVisible)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		public virtual void HandleFrame()
		{
			if (!IsVisible)
			{
				return;
			}
			try
			{
				if (!Minimap.IsOpen() || (Input.GetKeyDown((KeyCode)27) && !CcTextFocus.EscapeShouldOnlyBlur()))
				{
					Hide();
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		protected void SetTitle(string text)
		{
			if ((Object)(object)_title != (Object)null)
			{
				_title.text = text;
			}
		}

		protected abstract void BuildContent(GUIManager gui, Font font, Color headerColor, ref float y);

		protected virtual void OnShown()
		{
		}

		protected virtual void OnHidden()
		{
		}

		private bool EnsureBuilt()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Expected O, but got Unknown
			if (_failed)
			{
				return false;
			}
			if ((Object)(object)_panel != (Object)null)
			{
				return true;
			}
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			try
			{
				GUIManager instance = GUIManager.Instance;
				Font averiaSerifBold = instance.AveriaSerifBold;
				Color val = default(Color);
				((Color)(ref val))..ctor(0.9f, 0.8f, 0.6f, 1f);
				_panel = instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), DockPosition(1f), _width, _height, true);
				_appliedScale = 1f;
				_title = instance.CreateText(AtlasStrings.Get(_titleKey), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -28f), averiaSerifBold, 19, val, true, Color.black, _width - 40f, 30f, false).GetComponent<Text>();
				float y = -62f;
				BuildContent(instance, averiaSerifBold, val, ref y);
				((UnityEvent)instance.CreateButton(AtlasStrings.Get("workbench.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 30f), 110f, 30f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
				_panel.SetActive(false);
				return true;
			}
			catch (Exception exception)
			{
				Fail(exception);
				return false;
			}
		}

		private Vector2 DockPosition(float scale)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(0f - _width * scale / 2f - 30f, 0f);
		}

		protected void Fail(Exception exception)
		{
			_failed = true;
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			Log.LogError((object)(GetType().Name + " failed and was disabled for this session (console commands remain available): " + SafeLogText.Describe(exception)));
		}

		protected Text AddBody(GUIManager gui, Font font, string text, int size, Color color, ref float y, float height)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Text component = gui.CreateText(text, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y - height / 2f), font, size, color, false, Color.black, _width - 40f, height, false).GetComponent<Text>();
			component.alignment = (TextAnchor)0;
			component.verticalOverflow = (VerticalWrapMode)0;
			y -= height + 6f;
			return component;
		}

		protected Button AddButton(GUIManager gui, string label, float x, float y, float width, float height, Action onClick)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			Button component = gui.CreateButton(label, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(x, y), width, height).GetComponent<Button>();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				try
				{
					onClick();
				}
				catch (Exception exception)
				{
					Fail(exception);
				}
			});
			return component;
		}

		protected Toggle AddToggle(GUIManager gui, Font font, Color color, string label, float x, float y, Action<bool> onChanged, float labelWidth = 190f)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = gui.CreateToggle(_panel.transform, 24f, 24f);
			RectTransform val = (RectTransform)obj.transform;
			val.anchorMin = new Vector2(0.5f, 1f);
			val.anchorMax = new Vector2(0.5f, 1f);
			val.anchoredPosition = new Vector2(x, y);
			Text component = gui.CreateText(label, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(x + 18f + labelWidth / 2f, y), font, 13, color, false, Color.black, labelWidth, 26f, false).GetComponent<Text>();
			component.alignment = (TextAnchor)3;
			((Graphic)component).raycastTarget = false;
			Toggle componentInChildren = obj.GetComponentInChildren<Toggle>();
			((UnityEvent<bool>)(object)componentInChildren.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
			{
				try
				{
					if (!_suppressToggleEvents)
					{
						onChanged(value);
					}
				}
				catch (Exception exception)
				{
					Fail(exception);
				}
			});
			return componentInChildren;
		}

		protected void SetToggleSilently(Toggle toggle, bool value)
		{
			_suppressToggleEvents = true;
			try
			{
				toggle.isOn = value;
			}
			finally
			{
				_suppressToggleEvents = false;
			}
		}
	}
	internal static class CcTextFocus
	{
		private static int s_lastFocusedFrame = -10;

		public static bool AnyFieldFocused()
		{
			try
			{
				EventSystem current = EventSystem.current;
				GameObject val = (((Object)(object)current != (Object)null) ? current.currentSelectedGameObject : null);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				InputField component = val.GetComponent<InputField>();
				if ((Object)(object)component != (Object)null && component.isFocused)
				{
					s_lastFocusedFrame = Time.frameCount;
					return true;
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		public static bool EscapeShouldOnlyBlur()
		{
			if (AnyFieldFocused())
			{
				return true;
			}
			return Time.frameCount - s_lastFocusedFrame <= 1;
		}
	}
	internal sealed class CrashConsentPanel
	{
		private const float PanelWidth = 540f;

		private const float PanelHeight = 600f;

		private const float TextWidth = 492f;

		private readonly ManualLogSource _log;

		private readonly CartographerSettings _settings;

		private GameObject? _panel;

		private GameObject? _firstRunRows;

		private GameObject? _settingsRows;

		private Text? _stateLine;

		private Text? _toggleLabel;

		private bool _firstRunMode;

		private bool _failed;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public bool NeedsFirstRunPrompt
		{
			get
			{
				if (_settings.CrashReportingConsent.Value != CrashConsentState.Unknown)
				{
					return _settings.AcceptedPrivacyPolicyVersion.Value < 1;
				}
				return true;
			}
		}

		public CrashConsentPanel(ManualLogSource log, CartographerSettings settings)
		{
			_log = log;
			_settings = settings;
		}

		public void ShowFirstRun()
		{
			Show(firstRun: true);
		}

		public void ShowSettings()
		{
			Show(firstRun: false);
		}

		public void HandleFrame()
		{
			if (!IsVisible)
			{
				return;
			}
			try
			{
				if (Input.GetKeyDown((KeyCode)27) || !Minimap.IsOpen())
				{
					if (_firstRunMode)
					{
						Choose(CrashConsentState.Disabled);
					}
					else
					{
						Hide();
					}
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void Show(bool firstRun)
		{
			if (!EnsureBuilt())
			{
				return;
			}
			try
			{
				_firstRunMode = firstRun;
				_firstRunRows.SetActive(firstRun);
				_settingsRows.SetActive(!firstRun);
				if (!firstRun)
				{
					UpdateStateWidgets();
				}
				_panel.SetActive(true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void Hide()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
		}

		private void Choose(CrashConsentState state)
		{
			try
			{
				_settings.CrashReportingConsent.Value = state;
				_settings.AcceptedPrivacyPolicyVersion.Value = 1;
			}
			catch (Exception exception)
			{
				_log.LogWarning((object)("Could not persist the crash-reporting choice: " + SafeLogText.Brief(exception)));
			}
			Hide();
		}

		private void ToggleFromSettings()
		{
			CrashConsentState value = ((_settings.CrashReportingConsent.Value != CrashConsentState.Enabled) ? CrashConsentState.Enabled : CrashConsentState.Disabled);
			try
			{
				_settings.CrashReportingConsent.Value = value;
				_settings.AcceptedPrivacyPolicyVersion.Value = 1;
			}
			catch (Exception exception)
			{
				_log.LogWarning((object)("Could not persist the crash-reporting choice: " + SafeLogText.Brief(exception)));
			}
			UpdateStateWidgets();
		}

		private void UpdateStateWidgets()
		{
			bool flag = _settings.CrashReportingConsent.Value == CrashConsentState.Enabled;
			if ((Object)(object)_stateLine != (Object)null)
			{
				_stateLine.text = AtlasStrings.Format("privacy.settingsState", flag ? "ON" : "OFF");
			}
			if ((Object)(object)_toggleLabel != (Object)null)
			{
				_toggleLabel.text = AtlasStrings.Get(flag ? "privacy.turnOff" : "privacy.turnOn");
			}
		}

		private static void OpenPrivacyPolicy()
		{
			try
			{
				Application.OpenURL("https://github.com/Weakened/ConcernedCatMods/blob/main/PRIVACY.md");
			}
			catch
			{
			}
		}

		private bool EnsureBuilt()
		{
			if (_failed)
			{
				return false;
			}
			if ((Object)(object)_panel != (Object)null)
			{
				return true;
			}
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			try
			{
				Build();
				return (Object)(object)_panel != (Object)null;
			}
			catch (Exception exception)
			{
				Fail(exception);
				return false;
			}
		}

		private void Build()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Expected O, but got Unknown
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Expected O, but got Unknown
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Expected O, but got Unknown
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Expected O, but got Unknown
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Expected O, but got Unknown
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color val = default(Color);
			((Color)(ref val))..ctor(0.9f, 0.8f, 0.6f, 1f);
			_panel = instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 540f, 600f, false);
			instance.CreateText(AtlasStrings.Get("privacy.consentTitle"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -32f), averiaSerifBold, 19, val, true, Color.black, 492f, 30f, false);
			CreateBody(instance, averiaSerifBold, AtlasStrings.Get("privacy.consentQuestion"), 14, Color.white, -78f, 44f);
			CreateBody(instance, averiaSerifBold, AtlasStrings.Get("privacy.consentSent"), 12, new Color(0.85f, 1f, 0.85f, 1f), -140f, 70f);
			CreateBody(instance, averiaSerifBold, AtlasStrings.Get("privacy.consentNever"), 12, new Color(1f, 0.85f, 0.8f, 1f), -228f, 100f);
			CreateBody(instance, averiaSerifBold, AtlasStrings.Get("privacy.consentProvider"), 12, new Color(1f, 1f, 1f, 0.75f), -330f, 24f);
			_firstRunRows = new GameObject("CCConsentFirstRun", new Type[1] { typeof(RectTransform) });
			_firstRunRows.transform.SetParent(_panel.transform, false);
			FillRect(_firstRunRows);
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("privacy.consentYes"), _firstRunRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -390f), 320f, 38f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				Choose(CrashConsentState.Enabled);
			});
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("privacy.consentNo"), _firstRunRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-90f, -440f), 150f, 32f).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				Choose(CrashConsentState.Disabled);
			});
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("privacy.consentLearnMore"), _firstRunRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(90f, -440f), 150f, 32f).GetComponent<Button>().onClick).AddListener(new UnityAction(OpenPrivacyPolicy));
			_settingsRows = new GameObject("CCConsentSettings", new Type[1] { typeof(RectTransform) });
			_settingsRows.transform.SetParent(_panel.transform, false);
			FillRect(_settingsRows);
			_stateLine = instance.CreateText("", _settingsRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -382f), averiaSerifBold, 14, Color.white, false, Color.black, 492f, 26f, false).GetComponent<Text>();
			_stateLine.alignment = (TextAnchor)4;
			GameObject val2 = instance.CreateButton("", _settingsRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-90f, -424f), 150f, 32f);
			_toggleLabel = val2.GetComponentInChildren<Text>();
			((UnityEvent)val2.GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleFromSettings));
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("privacy.consentLearnMore"), _settingsRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(90f, -424f), 150f, 32f).GetComponent<Button>().onClick).AddListener(new UnityAction(OpenPrivacyPolicy));
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("workbench.close"), _settingsRows.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 36f), 120f, 32f).GetComponent<Button>().onClick).AddListener(new UnityAction(Hide));
			_settingsRows.SetActive(false);
			_panel.SetActive(false);
		}

		private void CreateBody(GUIManager gui, Font font, string text, int size, Color color, float y, float height)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			gui.CreateText(text, _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), font, size, color, false, Color.black, 492f, height, false).GetComponent<Text>().alignment = (TextAnchor)0;
		}

		private static void FillRect(GameObject target)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)target.transform;
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			_log.LogError((object)("Crash-reporting consent panel failed and was disabled for this session (reporting stays off until answered elsewhere): " + SafeLogText.Describe(exception)));
		}
	}
	internal static class LiveAlignmentProbe
	{
		public static string BuildReport(Vector3 playerPosition, bool standingOnRoad, RoadKind classifiedKind, RoadSurveyor.TraversalSample? latestSample, RoadObservation? lastAccepted, bool hasNearest, RoadPoint nearestPoint, float nearestDistanceMeters, RoadOverlayRenderer renderer)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_0613: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_0630: Unknown result type (might be due to invalid IL or missing references)
			//IL_063f: Unknown result type (might be due to invalid IL or missing references)
			//IL_064e: Unknown result type (might be due to invalid IL or missing references)
			//IL_065d: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(Invariant($"player: ({playerPosition.x:0.00}, {playerPosition.y:0.00}, {playerPosition.z:0.00})"));
			stringBuilder.Append('\n').Append(standingOnRoad ? Invariant($"terrain: {classifiedKind} road paint under the player") : "terrain: no road paint classified under the player");
			StringBuilder stringBuilder2 = stringBuilder.Append('\n');
			object value;
			if (latestSample.HasValue)
			{
				RoadSurveyor.TraversalSample valueOrDefault = latestSample.GetValueOrDefault();
				value = Invariant(FormattableStringFactory.Create("latest traversal sample: ({0:0.00}, {1:0.00}) classified={2} onRecordedRoad={3}", valueOrDefault.Position.x, valueOrDefault.Position.z, valueOrDefault.Classified ? valueOrDefault.Kind.ToString() : "no", valueOrDefault.OnRecordedRoad ? "yes" : "no"));
			}
			else
			{
				value = "latest traversal sample: none yet (sampler has not run)";
			}
			stringBuilder2.Append((string?)value);
			StringBuilder stringBuilder3 = stringBuilder.Append('\n');
			object value2;
			if (lastAccepted.HasValue)
			{
				RoadObservation valueOrDefault2 = lastAccepted.GetValueOrDefault();
				value2 = Invariant($"latest recorded construction point: {valueOrDefault2.Source}/{valueOrDefault2.Kind} ({valueOrDefault2.Position.X:0.00}, {valueOrDefault2.Position.Z:0.00})");
			}
			else
			{
				value2 = "latest recorded construction point: none this session";
			}
			stringBuilder3.Append((string?)value2);
			stringBuilder.Append('\n').Append(hasNearest ? Invariant($"nearest stored road point: ({nearestPoint.X:0.00}, {nearestPoint.Z:0.00}) at {nearestDistanceMeters:0.00} m") : "nearest stored road point: none within the search radius");
			int pixelX;
			int pixelY;
			bool flag = MinimapReflection.TryWorldToPixel(playerPosition, out pixelX, out pixelY);
			stringBuilder.Append('\n').Append(flag ? Invariant($"native WorldToPixel: ({pixelX}, {pixelY})") : "native WorldToPixel: n/a");
			int textureSize;
			bool flag2 = MinimapReflection.TryGetTextureSize(out textureSize) && textureSize > 0;
			float mapX;
			float mapY;
			bool flag3 = MinimapReflection.TryWorldToMapPoint(playerPosition, out mapX, out mapY);
			if (flag3 && flag2)
			{
				stringBuilder.Append('\n').Append(Invariant($"native WorldToMapPoint: ({mapX:0.00000}, {mapY:0.00000}) = texel ({mapX * (float)textureSize:0.00}, {mapY * (float)textureSize:0.00})"));
			}
			else
			{
				stringBuilder.Append('\n').Append("native WorldToMapPoint: n/a");
			}
			Vector2 overlayCoords;
			int overlaySize;
			bool flag4 = renderer.TryGetOverlayProjection(playerPosition, out overlayCoords, out overlaySize);
			stringBuilder.Append('\n').Append(flag4 ? Invariant($"CC overlay projection: ({overlayCoords.x:0.00}, {overlayCoords.y:0.00}) of {overlaySize}") : "CC overlay projection: n/a");
			bool hasProjectionDelta = false;
			float num = 0f;
			if (flag && flag2)
			{
				if (flag3)
				{
					hasProjectionDelta = true;
					num = Delta(mapX * (float)textureSize, mapY * (float)textureSize, pixelX, pixelY);
				}
				if (flag4 && overlaySize > 0)
				{
					float num2 = (float)textureSize / (float)overlaySize;
					hasProjectionDelta = true;
					num = Mathf.Max(num, Delta(overlayCoords.x * num2, overlayCoords.y * num2, pixelX, pixelY));
				}
			}
			float metersPerPixel;
			string text = (MinimapReflection.TryGetPixelSize(out metersPerPixel) ? Invariant($"{metersPerPixel:0.###}") : "n/a");
			float zoom;
			string text2 = (MinimapReflection.TryGetLargeZoom(out zoom) ? Invariant($"{zoom:0.####}") : "n/a");
			float num3 = 0f;
			bool hasMarkerDelta = false;
			float markerDeltaPixels = 0f;
			string value3 = "live marker: n/a (large map closed?)";
			try
			{
				Minimap instance = Minimap.instance;
				if ((Object)(object)instance != (Object)null && (Object)(object)instance.m_mapImageLarge != (Object)null && (Object)(object)instance.m_largeRoot != (Object)null && instance.m_largeRoot.activeInHierarchy)
				{
					RawImage mapImageLarge = instance.m_mapImageLarge;
					Rect uvRect = mapImageLarge.uvRect;
					Rect rect = ((Graphic)mapImageLarge).rectTransform.rect;
					if (flag2 && ((Rect)(ref uvRect)).width > 0f && ((Rect)(ref rect)).width > 0f && MapScreenMath.TryGetPixelsPerGuiUnit(mapImageLarge, out var pixelsPerGuiUnit))
					{
						num3 = pixelsPerGuiUnit * ((Rect)(ref rect)).width / (((Rect)(ref uvRect)).width * (float)textureSize);
					}
					stringBuilder.Append('\n').Append(Invariant($"large map uvRect: ({((Rect)(ref uvRect)).xMin:0.00000}, {((Rect)(ref uvRect)).yMin:0.00000}, {((Rect)(ref uvRect)).width:0.00000}, {((Rect)(ref uvRect)).height:0.00000}) rect {((Rect)(ref rect)).width:0.#}x{((Rect)(ref rect)).height:0.#}"));
					RectTransform largeMarker = instance.m_largeMarker;
					if (flag3 && (Object)(object)largeMarker != (Object)null && ((Component)largeMarker).gameObject.activeInHierarchy && ((Rect)(ref uvRect)).width > 0f && ((Rect)(ref uvRect)).height > 0f)
					{
						var (num4, num5) = RoadVectorMath.VanillaLocalGuiPosition(mapX, mapY, ((Rect)(ref uvRect)).xMin, ((Rect)(ref uvRect)).yMin, ((Rect)(ref uvRect)).width, ((Rect)(ref uvRect)).height, ((Rect)(ref rect)).width, ((Rect)(ref rect)).height);
						if (MapScreenMath.TryLocalGuiToScreenPoint(mapImageLarge, new Vector2(num4, num5), out var screenPoint) && MapScreenMath.TryTransformToScreenPoint(mapImageLarge, (Transform)(object)largeMarker, out var screenPoint2))
						{
							hasMarkerDelta = true;
							Vector2 val = screenPoint2 - screenPoint;
							markerDeltaPixels = ((Vector2)(ref val)).magnitude;
							value3 = Invariant($"live marker: screen ({screenPoint2.x:0.0}, {screenPoint2.y:0.0}) vs expected ({screenPoint.x:0.0}, {screenPoint.y:0.0})");
						}
					}
					else if ((Object)(object)largeMarker == (Object)null || !((Component)largeMarker).gameObject.activeInHierarchy)
					{
						value3 = "live marker: n/a (marker hidden — aboard a ship?)";
					}
				}
			}
			catch (Exception ex)
			{
				value3 = "live marker: n/a (" + ex.Message + ")";
			}
			string text3 = (flag2 ? textureSize.ToString(CultureInfo.InvariantCulture) : "n/a");
			stringBuilder.Append('\n').Append(Invariant($"mapTextureSize={text3} metersPerTexel={text} largeZoom={text2} screenPxPerTexel={num3:0.0}"));
			stringBuilder.Append('\n').Append(value3);
			bool vectorLayerActive = renderer.VectorLayerActive;
			stringBuilder.Append('\n').Append(vectorLayerActive ? "vector road layer: ACTIVE (sub-texel large-map ink)" : "vector road layer: inactive");
			string text4 = AlignmentVerdicts.Evaluate(standingOnRoad, hasNearest, nearestDistanceMeters, hasProjectionDelta, num, num3, vectorLayerActive, hasMarkerDelta, markerDeltaPixels);
			return stringBuilder.ToString() + "\n" + text4;
		}

		private static float Delta(float x, float y, int pixelX, int pixelY)
		{
			float num = x - (float)pixelX;
			float num2 = y - (float)pixelY;
			return Mathf.Sqrt(num * num + num2 * num2);
		}

		private static string Invariant(FormattableString text)
		{
			return text.ToString(CultureInfo.InvariantCulture);
		}
	}
	internal static class MapInputGate
	{
		public static volatile bool ConsumeClicks;

		public static Func<bool>? WheelGuard;

		private static Harmony? s_harmony;

		private static readonly FieldRef<Minimap, float>? LargeZoomField = BuildZoomRef("m_largeZoom");

		private static readonly FieldRef<Minimap, float>? SmallZoomField = BuildZoomRef("m_smallZoom");

		[ThreadStatic]
		private static bool t_restoreZoom;

		[ThreadStatic]
		private static float t_savedLargeZoom;

		[ThreadStatic]
		private static float t_savedSmallZoom;

		[ThreadStatic]
		private static Rect t_savedLargeUv;

		[ThreadStatic]
		private static Rect t_savedSmallUv;

		public static void Install(ManualLogSource log)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00d7: Expected O, but got Unknown
			if (s_harmony != null)
			{
				return;
			}
			try
			{
				Harmony val = new Harmony("com.theconcernedcat.valheim.concernedcartographer.mapinput");
				val.Patch((MethodBase)AccessTools.Method(typeof(Minimap), "OnMapLeftClick", (Type[])null, (Type[])null), new HarmonyMethod(typeof(MapInputGate), "BeforeMapClick", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				val.Patch((MethodBase)AccessTools.Method(typeof(Minimap), "OnMapDblClick", (Type[])null, (Type[])null), new HarmonyMethod(typeof(MapInputGate), "BeforeMapClick", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				if (LargeZoomField != null && SmallZoomField != null)
				{
					val.Patch((MethodBase)AccessTools.Method(typeof(Minimap), "UpdateMap", (Type[])null, (Type[])null), new HarmonyMethod(typeof(MapInputGate), "BeforeUpdateMap", (Type[])null), new HarmonyMethod(typeof(MapInputGate), "AfterUpdateMap", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					log.LogWarning((object)"Map wheel guard unavailable (zoom fields not found); scrolling CC lists may zoom the map.");
				}
				s_harmony = val;
			}
			catch (Exception exception)
			{
				log.LogWarning((object)("Map input gate unavailable (route drawing may also toggle pins under the cursor): " + SafeLogText.Brief(exception)));
			}
		}

		public static void Uninstall()
		{
			ConsumeClicks = false;
			WheelGuard = null;
			try
			{
				Harmony? obj = s_harmony;
				if (obj != null)
				{
					obj.UnpatchSelf();
				}
			}
			catch
			{
			}
			s_harmony = null;
		}

		private static bool BeforeMapClick()
		{
			return !ConsumeClicks;
		}

		private static void BeforeUpdateMap(Minimap __instance)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			t_restoreZoom = false;
			try
			{
				Func<bool>? wheelGuard = WheelGuard;
				if (wheelGuard != null && wheelGuard())
				{
					t_savedLargeZoom = LargeZoomField.Invoke(__instance);
					t_savedSmallZoom = SmallZoomField.Invoke(__instance);
					if ((Object)(object)__instance.m_mapImageLarge != (Object)null)
					{
						t_savedLargeUv = __instance.m_mapImageLarge.uvRect;
					}
					if ((Object)(object)__instance.m_mapImageSmall != (Object)null)
					{
						t_savedSmallUv = __instance.m_mapImageSmall.uvRect;
					}
					t_restoreZoom = true;
				}
			}
			catch
			{
				t_restoreZoom = false;
			}
		}

		private static void AfterUpdateMap(Minimap __instance)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (!t_restoreZoom)
			{
				return;
			}
			t_restoreZoom = false;
			try
			{
				LargeZoomField.Invoke(__instance) = t_savedLargeZoom;
				SmallZoomField.Invoke(__instance) = t_savedSmallZoom;
				if ((Object)(object)__instance.m_mapImageLarge != (Object)null)
				{
					__instance.m_mapImageLarge.uvRect = t_savedLargeUv;
				}
				if ((Object)(object)__instance.m_mapImageSmall != (Object)null)
				{
					__instance.m_mapImageSmall.uvRect = t_savedSmallUv;
				}
			}
			catch
			{
			}
		}

		private static FieldRef<Minimap, float>? BuildZoomRef(string fieldName)
		{
			try
			{
				return AccessTools.FieldRefAccess<Minimap, float>(fieldName);
			}
			catch
			{
				return null;
			}
		}
	}
	internal static class MapPointerGuard
	{
		private static readonly List<Func<GameObject?>> LargeMapWidgets = new List<Func<GameObject>>();

		public static void RegisterWidget(Func<GameObject?> widget)
		{
			LargeMapWidgets.Add(widget);
		}

		public static void Clear()
		{
			LargeMapWidgets.Clear();
		}

		public static bool IsPointerOverCcUi(Vector2 screenPosition)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject customGUIFront = GUIManager.CustomGUIFront;
				if ((Object)(object)customGUIFront != (Object)null)
				{
					Transform transform = customGUIFront.transform;
					for (int i = 0; i < transform.childCount; i++)
					{
						Transform child = transform.GetChild(i);
						if (((Component)child).gameObject.activeInHierarchy)
						{
							RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
							if (val != null && ContainsScreenPoint(val, screenPosition))
							{
								return true;
							}
						}
					}
				}
				foreach (Func<GameObject> largeMapWidget in LargeMapWidgets)
				{
					GameObject val2 = largeMapWidget();
					if ((Object)(object)val2 != (Object)null && val2.activeInHierarchy)
					{
						Transform transform2 = val2.transform;
						RectTransform val3 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
						if (val3 != null && ContainsScreenPoint(val3, screenPosition))
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool ContainsScreenPoint(RectTransform rect, Vector2 screenPosition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInParent = ((Component)rect).GetComponentInParent<Canvas>();
			Camera val = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.rootCanvas.renderMode != 0) ? componentInParent.rootCanvas.worldCamera : null);
			return RectTransformUtility.RectangleContainsScreenPoint(rect, screenPosition, val);
		}
	}
	internal static class MapScreenMath
	{
		private static readonly Vector3[] Corners = (Vector3[])(object)new Vector3[4];

		public static Camera? CanvasCamera(Graphic graphic)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Canvas canvas = graphic.canvas;
			if ((Object)(object)canvas == (Object)null)
			{
				return null;
			}
			if ((int)canvas.renderMode != 0)
			{
				return canvas.worldCamera;
			}
			return null;
		}

		public static bool TryGetPixelsPerGuiUnit(RawImage image, out float pixelsPerGuiUnit)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			pixelsPerGuiUnit = 1f;
			if ((Object)(object)image == (Object)null)
			{
				return false;
			}
			RectTransform rectTransform = ((Graphic)image).rectTransform;
			Rect rect = rectTransform.rect;
			float width = ((Rect)(ref rect)).width;
			if (width <= 0f)
			{
				return false;
			}
			Camera? obj = CanvasCamera((Graphic)(object)image);
			rectTransform.GetWorldCorners(Corners);
			Vector2 val = RectTransformUtility.WorldToScreenPoint(obj, Corners[0]);
			Vector2 val2 = RectTransformUtility.WorldToScreenPoint(obj, Corners[3]) - val;
			float magnitude = ((Vector2)(ref val2)).magnitude;
			if (magnitude <= 0f)
			{
				return false;
			}
			pixelsPerGuiUnit = magnitude / width;
			return true;
		}

		public static bool TryLocalGuiToScreenPoint(RawImage image, Vector2 bottomLeftRelative, out Vector2 screenPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			screenPoint = default(Vector2);
			if ((Object)(object)image == (Object)null)
			{
				return false;
			}
			RectTransform rectTransform = ((Graphic)image).rectTransform;
			Rect rect = rectTransform.rect;
			Vector2 val = ((Rect)(ref rect)).min + bottomLeftRelative;
			Vector3 val2 = ((Transform)rectTransform).TransformPoint(Vector2.op_Implicit(val));
			screenPoint = RectTransformUtility.WorldToScreenPoint(CanvasCamera((Graphic)(object)image), val2);
			return true;
		}

		public static bool TryTransformToScreenPoint(RawImage referenceImage, Transform target, out Vector2 screenPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			screenPoint = default(Vector2);
			if ((Object)(object)referenceImage == (Object)null || (Object)(object)target == (Object)null)
			{
				return false;
			}
			screenPoint = RectTransformUtility.WorldToScreenPoint(CanvasCamera((Graphic)(object)referenceImage), target.position);
			return true;
		}
	}
	internal sealed class MapUiCoordinator
	{
		private const float ToolbarHeight = 32f;

		private const float HintClearanceMargin = 12f;

		private const float FallbackToolbarY = 108f;

		private const float HintTextDelta = 38f;

		private const float ContextButtonDelta = 70f;

		private readonly ManualLogSource _log;

		private GameObject? _toolbar;

		private Text? _tooltipText;

		private Text? _hintText;

		private GameObject? _contextButton;

		private Text? _contextLabel;

		private Action? _contextAction;

		private bool _pointerOverContext;

		private float _appliedToolbarY = -1f;

		private bool _failed;

		private readonly List<(Func<bool> IsVisible, Action Close)> _surfaces = new List<(Func<bool>, Action)>();

		public Action? AtlasClicked;

		public Action? MarkersClicked;

		public Action? RoutesClicked;

		public Action? SurveyClicked;

		public Action? ShareClicked;

		public Action? QuickPinClicked;

		public Action? SettingsClicked;

		public bool PointerOverContext => _pointerOverContext;

		public GameObject? ToolbarObject => _toolbar;

		public GameObject? ContextButtonObject => _contextButton;

		public bool HasFailed => _failed;

		public bool AnySurfaceVisible
		{
			get
			{
				foreach (var surface in _surfaces)
				{
					if (SafeIsVisible(surface.IsVisible))
					{
						return true;
					}
				}
				return false;
			}
		}

		public MapUiCoordinator(ManualLogSource log)
		{
			_log = log;
		}

		public int RegisterSurface(Func<bool> isVisible, Action close)
		{
			_surfaces.Add((isVisible, close));
			return _surfaces.Count - 1;
		}

		public void OpenExclusive(int selfToken, Action openOrToggle)
		{
			try
			{
				for (int i = 0; i < _surfaces.Count; i++)
				{
					if (i != selfToken && SafeIsVisible(_surfaces[i].IsVisible))
					{
						_surfaces[i].Close();
					}
				}
				openOrToggle();
			}
			catch (Exception exception)
			{
				_log.LogWarning((object)("Map surface switch failed: " + SafeLogText.Brief(exception)));
			}
		}

		public void CloseAllSurfaces()
		{
			foreach (var (isVisible, action) in _surfaces)
			{
				if (SafeIsVisible(isVisible))
				{
					try
					{
						action();
					}
					catch
					{
					}
				}
			}
		}

		private static bool SafeIsVisible(Func<bool> isVisible)
		{
			try
			{
				return isVisible();
			}
			catch
			{
				return false;
			}
		}

		public void EnsureBuilt(string drawerHotkeyName)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Expected O, but got Unknown
			if (_failed || (Object)(object)_toolbar != (Object)null)
			{
				return;
			}
			try
			{
				GameObject val = (((Object)(object)Minimap.instance != (Object)null) ? Minimap.instance.m_largeRoot : null);
				if ((Object)(object)val == (Object)null || !val.activeInHierarchy || GUIManager.Instance == null)
				{
					return;
				}
				GUIManager instance = GUIManager.Instance;
				float num = (_appliedToolbarY = ComputeToolbarY(val));
				_toolbar = new GameObject("CCToolbar", new Type[1] { typeof(RectTransform) });
				_toolbar.transform.SetParent(val.transform, false);
				RectTransform val2 = (RectTransform)_toolbar.transform;
				val2.anchorMin = new Vector2(0.5f, 0f);
				val2.anchorMax = new Vector2(0.5f, 0f);
				val2.anchoredPosition = new Vector2(0f, num);
				val2.sizeDelta = new Vector2(720f, 32f);
				(string, Func<Action>)[] array = new(string, Func<Action>)[7]
				{
					("toolbar.atlas", () => AtlasClicked),
					("toolbar.markers", () => MarkersClicked),
					("toolbar.routes", () => RoutesClicked),
					("toolbar.survey", () => SurveyClicked),
					("toolbar.share", () => ShareClicked),
					("toolbar.quickpin", () => QuickPinClicked),
					("toolbar.settings", () => SettingsClicked)
				};
				float num2 = (0f - ((float)array.Length * 98f + (float)(array.Length - 1) * 4f)) / 2f + 49f;
				(string, Func<Action>)[] array2 = array;
				for (int num3 = 0; num3 < array2.Length; num3++)
				{
					(string, Func<Action>) tuple = array2[num3];
					string item = tuple.Item1;
					Func<Action> item2 = tuple.Item2;
					GameObject obj = instance.CreateButton(AtlasStrings.Get(item), _toolbar.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(num2, 0f), 98f, 30f);
					Func<Action?> captured = item2;
					((UnityEvent)obj.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						captured()?.Invoke();
					});
					num2 += 102f;
				}
				_tooltipText = instance.CreateText(AtlasStrings.Format("hud.atlasTooltip", drawerHotkeyName), val.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, num + 38f), instance.AveriaSerifBold, 13, new Color(1f, 0.95f, 0.75f, 1f), true, Color.black, 700f, 24f, false).GetComponent<Text>();
				_tooltipText.alignment = (TextAnchor)4;
				((Component)_tooltipText).gameObject.SetActive(false);
				if (_toolbar.transform.childCount > 0)
				{
					AddHoverHandlers(((Component)_toolbar.transform.GetChild(0)).gameObject, delegate
					{
						Text? tooltipText = _tooltipText;
						if (tooltipText != null)
						{
							((Component)tooltipText).gameObject.SetActive(true);
						}
					}, delegate
					{
						Text? tooltipText = _tooltipText;
						if (tooltipText != null)
						{
							((Component)tooltipText).gameObject.SetActive(false);
						}
					});
				}
				_hintText = instance.CreateText("", val.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, num + 38f), instance.AveriaSerifBold, 15, new Color(1f, 0.95f, 0.75f, 1f), true, Color.black, 700f, 24f, false).GetComponent<Text>();
				_hintText.alignment = (TextAnchor)4;
				((Component)_hintText).gameObject.SetActive(false);
				_contextButton = instance.CreateButton("", val.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, num + 70f), 220f, 32f);
				_contextLabel = _contextButton.GetComponentInChildren<Text>();
				((UnityEvent)_contextButton.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					Action? contextAction = _contextAction;
					_pointerOverContext = false;
					SetContext(null, null);
					contextAction?.Invoke();
				});
				AddHoverHandlers(_contextButton, delegate
				{
					_pointerOverContext = true;
				}, delegate
				{
					_pointerOverContext = false;
				});
				_contextButton.SetActive(false);
			}
			catch (Exception exception)
			{
				_failed = true;
				_log.LogError((object)("Map toolbar failed and is disabled for this session (hotkeys still work): " + SafeLogText.Describe(exception)));
			}
		}

		private static float ComputeToolbarY(GameObject largeRoot)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			bool flag = false;
			try
			{
				Transform transform = largeRoot.transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if ((Object)(object)val == (Object)null)
				{
					return 108f;
				}
				Rect rect = val.rect;
				float yMin = ((Rect)(ref rect)).yMin;
				rect = val.rect;
				float height = ((Rect)(ref rect)).height;
				List<GameObject> list = new List<GameObject>();
				Minimap instance = Minimap.instance;
				if ((Object)(object)instance != (Object)null)
				{
					if (instance.m_hints != null)
					{
						list.AddRange(instance.m_hints);
					}
					if ((Object)(object)instance.m_sharedMapHint != (Object)null)
					{
						list.Add(instance.m_sharedMapHint);
					}
				}
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				foreach (GameObject item in list)
				{
					if ((Object)(object)item == (Object)null || !item.activeInHierarchy)
					{
						continue;
					}
					Transform transform2 = item.transform;
					RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						val2.GetWorldCorners(array);
						float num2 = float.MinValue;
						float num3 = float.MaxValue;
						for (int i = 0; i < 4; i++)
						{
							float num4 = ((Transform)val).InverseTransformPoint(array[i]).y - yMin;
							num2 = Mathf.Max(num2, num4);
							num3 = Mathf.Min(num3, num4);
						}
						if (!(height <= 0f) && !(num3 > height * 0.4f))
						{
							flag = true;
							num = Mathf.Max(num, num2);
						}
					}
				}
			}
			catch
			{
				return 108f;
			}
			if (!flag)
			{
				return 108f;
			}
			return num + 12f + 16f;
		}

		public void UpdateLayout()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if (_failed || (Object)(object)_toolbar == (Object)null)
			{
				return;
			}
			try
			{
				GameObject val = (((Object)(object)Minimap.instance != (Object)null) ? Minimap.instance.m_largeRoot : null);
				if ((Object)(object)val == (Object)null || !val.activeInHierarchy)
				{
					return;
				}
				float num = ComputeToolbarY(val);
				if (!(Mathf.Abs(num - _appliedToolbarY) < 0.5f))
				{
					_appliedToolbarY = num;
					((RectTransform)_toolbar.transform).anchoredPosition = new Vector2(0f, num);
					if ((Object)(object)_tooltipText != (Object)null)
					{
						((RectTransform)((Component)_tooltipText).transform).anchoredPosition = new Vector2(0f, num + 38f);
					}
					if ((Object)(object)_hintText != (Object)null)
					{
						((RectTransform)((Component)_hintText).transform).anchoredPosition = new Vector2(0f, num + 38f);
					}
					if ((Object)(object)_contextButton != (Object)null)
					{
						((RectTransform)_contextButton.transform).anchoredPosition = new Vector2(0f, num + 70f);
					}
				}
			}
			catch (Exception exception)
			{
				_failed = true;
				_log.LogError((object)("Map toolbar layout failed and is disabled for this session: " + SafeLogText.Describe(exception)));
			}
		}

		public void SetHint(string? text)
		{
			if (_failed || (Object)(object)_hintText == (Object)null)
			{
				return;
			}
			try
			{
				bool flag = !string.IsNullOrEmpty(text);
				if (flag && _hintText.text != text)
				{
					_hintText.text = text;
				}
				if (((Component)_hintText).gameObject.activeSelf != flag)
				{
					((Component)_hintText).gameObject.SetActive(flag);
				}
			}
			catch (Exception exception)
			{
				_failed = true;
				_log.LogError((object)("Map hint failed and is disabled for this session: " + SafeLogText.Describe(exception)));
			}
		}

		public void SetContext(string? label, Action? action)
		{
			if (_failed || (Object)(object)_contextButton == (Object)null)
			{
				return;
			}
			try
			{
				bool flag = !string.IsNullOrEmpty(label) && action != null;
				_contextAction = (flag ? action : null);
				if (flag && (Object)(object)_contextLabel != (Object)null && _contextLabel.text != label)
				{
					_contextLabel.text = label;
				}
				if (_contextButton.activeSelf != flag)
				{
					_contextButton.SetActive(flag);
					if (!flag)
					{
						_pointerOverContext = false;
					}
				}
			}
			catch (Exception exception)
			{
				_failed = true;
				_log.LogError((object)("Map context action failed and is disabled for this session: " + SafeLogText.Describe(exception)));
			}
		}

		public void Reset()
		{
			_appliedToolbarY = -1f;
			_toolbar = null;
			_tooltipText = null;
			_hintText = null;
			_contextButton = null;
			_contextLabel = null;
			_contextAction = null;
			_pointerOverContext = false;
		}

		private static void AddHoverHandlers(GameObject target, Action onEnter, Action onExit)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			EventTrigger obj = target.AddComponent<EventTrigger>();
			Entry val = new Entry
			{
				eventID = (EventTriggerType)0
			};
			((UnityEvent<BaseEventData>)(object)val.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				onEnter();
			});
			obj.triggers.Add(val);
			Entry val2 = new Entry
			{
				eventID = (EventTriggerType)1
			};
			((UnityEvent<BaseEventData>)(object)val2.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				onExit();
			});
			obj.triggers.Add(val2);
		}
	}
	internal static class MinimapReflection
	{
		private static readonly MethodInfo? ScreenToWorldMethod = AccessTools.Method(typeof(Minimap), "ScreenToWorldPoint", new Type[1] { typeof(Vector3) }, (Type[])null);

		private static readonly FastInvokeHandler? ScreenToWorldInvoker = (((object)ScreenToWorldMethod == null) ? null : MethodInvoker.GetHandler(ScreenToWorldMethod, false));

		private static readonly FieldRef<Minimap, float>? LargeZoomField = BuildLargeZoomRef();

		private static readonly MethodInfo? WorldToPixelMethod = AccessTools.Method(typeof(Minimap), "WorldToPixel", new Type[3]
		{
			typeof(Vector3),
			typeof(int).MakeByRefType(),
			typeof(int).MakeByRefType()
		}, (Type[])null);

		private static readonly FastInvokeHandler? WorldToPixelInvoker = (((object)WorldToPixelMethod == null) ? null : MethodInvoker.GetHandler(WorldToPixelMethod, false));

		private static readonly MethodInfo? WorldToMapPointMethod = AccessTools.Method(typeof(Minimap), "WorldToMapPoint", new Type[3]
		{
			typeof(Vector3),
			typeof(float).MakeByRefType(),
			typeof(float).MakeByRefType()
		}, (Type[])null);

		private static readonly FastInvokeHandler? WorldToMapPointInvoker = (((object)WorldToMapPointMethod == null) ? null : MethodInvoker.GetHandler(WorldToMapPointMethod, false));

		private static readonly FieldRef<Minimap, int>? TextureSizeField = BuildFieldRef<int>("m_textureSize");

		private static readonly FieldRef<Minimap, float>? PixelSizeField = BuildFieldRef<float>("m_pixelSize");

		private static readonly FieldRef<Minimap, PinData>? NamePinField = BuildFieldRef<PinData>("m_namePin");

		private static readonly MethodInfo? SelectIconMethod = AccessTools.Method(typeof(Minimap), "SelectIcon", new Type[1] { typeof(PinType) }, (Type[])null);

		private static readonly FastInvokeHandler? SelectIconInvoker = (((object)SelectIconMethod == null) ? null : MethodInvoker.GetHandler(SelectIconMethod, false));

		private static readonly FieldRef<Minimap, bool[]>? VisibleIconTypesField = BuildFieldRef<bool[]>("m_visibleIconTypes");

		private static readonly MethodInfo? ToggleIconFilterMethod = AccessTools.Method(typeof(Minimap), "ToggleIconFilter", new Type[1] { typeof(PinType) }, (Type[])null);

		private static readonly FastInvokeHandler? ToggleIconFilterInvoker = (((object)ToggleIconFilterMethod == null) ? null : MethodInvoker.GetHandler(ToggleIconFilterMethod, false));

		private static readonly FieldRef<Minimap, bool>? DragViewField = BuildFieldRef<bool>("m_dragView");

		private static readonly FieldRef<Minimap, RectTransform>? PinRootLargeField = BuildFieldRef<RectTransform>("m_pinRootLarge");

		private static readonly FieldRef<Minimap, RectTransform>? PinNameRootLargeField = BuildFieldRef<RectTransform>("m_pinNameRootLarge");

		private static readonly FieldRef<Minimap, Text>? BiomeNameLargeField = BuildFieldRef<Text>("m_biomeNameLarge");

		private static readonly MethodInfo? GetSpriteMethod = AccessTools.Method(typeof(Minimap), "GetSprite", new Type[1] { typeof(PinType) }, (Type[])null);

		private static readonly FastInvokeHandler? GetSpriteInvoker = (((object)GetSpriteMethod == null) ? null : MethodInvoker.GetHandler(GetSpriteMethod, false));

		private static readonly MethodInfo? IsExploredMethod = AccessTools.Method(typeof(Minimap), "IsExplored", new Type[1] { typeof(Vector3) }, (Type[])null);

		private static readonly FastInvokeHandler? IsExploredInvoker = (((object)IsExploredMethod == null) ? null : MethodInvoker.GetHandler(IsExploredMethod, false));

		public static bool TryWorldToPixel(Vector3 world, out int pixelX, out int pixelY)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			pixelX = 0;
			pixelY = 0;
			if (WorldToPixelInvoker == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				object[] array = new object[3] { world, 0, 0 };
				WorldToPixelInvoker.Invoke((object)Minimap.instance, array);
				pixelX = (int)array[1];
				pixelY = (int)array[2];
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryWorldToMapPoint(Vector3 world, out float mapX, out float mapY)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			mapX = 0f;
			mapY = 0f;
			if (WorldToMapPointInvoker == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				object[] array = new object[3] { world, 0f, 0f };
				WorldToMapPointInvoker.Invoke((object)Minimap.instance, array);
				mapX = (float)array[1];
				mapY = (float)array[2];
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryGetTextureSize(out int textureSize)
		{
			textureSize = 0;
			if (TextureSizeField == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				textureSize = TextureSizeField.Invoke(Minimap.instance);
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryGetPixelSize(out float metersPerPixel)
		{
			metersPerPixel = 0f;
			if (PixelSizeField == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				metersPerPixel = PixelSizeField.Invoke(Minimap.instance);
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryGetLargeZoom(out float zoom)
		{
			zoom = 0f;
			if (LargeZoomField == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				zoom = LargeZoomField.Invoke(Minimap.instance);
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryGetNamePin(out PinData? namePin)
		{
			namePin = null;
			if (NamePinField == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				namePin = NamePinField.Invoke(Minimap.instance);
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TrySelectIcon(int vanillaType)
		{
			if (SelectIconInvoker == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				SelectIconInvoker.Invoke((object)Minimap.instance, new object[1] { (object)(PinType)vanillaType });
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static List<GameObject> GetPlaceableIconButtons()
		{
			List<GameObject> list = new List<GameObject>();
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return list;
			}
			try
			{
				Image[] array = (Image[])(object)new Image[5] { instance.m_selectedIcon0, instance.m_selectedIcon1, instance.m_selectedIcon2, instance.m_selectedIcon3, instance.m_selectedIcon4 };
				foreach (Image val in array)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).transform.parent != (Object)null)
					{
						list.Add(((Component)((Component)val).transform.parent).gameObject);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		public static bool TryGetIconFilterVisible(int vanillaType, out bool visible)
		{
			visible = true;
			if (VisibleIconTypesField == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				bool[] array = VisibleIconTypesField.Invoke(Minimap.instance);
				if (array == null || vanillaType < 0 || vanillaType >= array.Length)
				{
					return false;
				}
				visible = array[vanillaType];
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryToggleIconFilter(int vanillaType)
		{
			if (ToggleIconFilterInvoker == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				ToggleIconFilterInvoker.Invoke((object)Minimap.instance, new object[1] { (object)(PinType)vanillaType });
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TrySuppressMapDragThisFrame()
		{
			if (DragViewField == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				DragViewField.Invoke(Minimap.instance) = false;
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryGetVanillaRailContainers(out GameObject? placeablesContainer, out GameObject? filtersContainer, out bool sharedContainer, out string diagnostics)
		{
			placeablesContainer = null;
			filtersContainer = null;
			sharedContainer = false;
			diagnostics = "";
			try
			{
				Minimap instance = Minimap.instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_largeRoot == (Object)null)
				{
					diagnostics = "minimap not ready";
					return false;
				}
				List<Transform> list = ToTransforms(GetPlaceableIconButtons());
				List<Transform> list2 = ToTransforms(GetSystemFilterButtons());
				if (list.Count < 5 || list2.Count < 2)
				{
					diagnostics = $"rail incomplete ({list.Count}/5 selectors, {list2.Count}/2 filters)";
					return false;
				}
				Transform transform = instance.m_largeRoot.transform;
				Transform val = DeepestCommonAncestor(list, transform);
				Transform val2 = DeepestCommonAncestor(list2, transform);
				List<Transform> otherGroup = new List<Transform>();
				if ((Object)(object)val != (Object)null && (Object)(object)val == (Object)(object)val2)
				{
					string text = ValidateRailContainer(instance, val, transform, otherGroup);
					if (text.Length != 0)
					{
						diagnostics = "shared rail container: " + text;
						return false;
					}
					placeablesContainer = ((Component)val).gameObject;
					filtersContainer = ((Component)val).gameObject;
					sharedContainer = true;
					diagnostics = "shared rail container '" + ((Object)val).name + "'";
					return true;
				}
				string text2 = ValidateRailContainer(instance, val, transform, list2);
				string text3 = ValidateRailContainer(instance, val2, transform, list);
				if (text2.Length == 0)
				{
					placeablesContainer = ((Component)val).gameObject;
				}
				if (text3.Length == 0)
				{
					filtersContainer = ((Component)val2).gameObject;
				}
				diagnostics = "selectors: " + ((text2.Length == 0) ? ("'" + ((Object)val).name + "'") : text2) + "; filters: " + ((text3.Length == 0) ? ("'" + ((Object)val2).name + "'") : text3);
				return (Object)(object)placeablesContainer != (Object)null || (Object)(object)filtersContainer != (Object)null;
			}
			catch (Exception ex)
			{
				diagnostics = ex.Message;
				return false;
			}
		}

		private static List<Transform> ToTransforms(List<GameObject> objects)
		{
			List<Transform> list = new List<Transform>();
			foreach (GameObject @object in objects)
			{
				if ((Object)(object)@object != (Object)null)
				{
					list.Add(@object.transform);
				}
			}
			return list;
		}

		private static Transform? DeepestCommonAncestor(List<Transform> members, Transform stopAt)
		{
			Transform parent = members[0].parent;
			while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)stopAt)
			{
				bool flag = true;
				foreach (Transform member in members)
				{
					if (!member.IsChildOf(parent))
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return parent;
				}
				parent = parent.parent;
			}
			return null;
		}

		private static string ValidateRailContainer(Minimap minimap, Transform? candidate, Transform largeRoot, List<Transform> otherGroup)
		{
			if ((Object)(object)candidate == (Object)null)
			{
				return "no common ancestor below the large root";
			}
			if ((Object)(object)candidate == (Object)(object)largeRoot || !candidate.IsChildOf(largeRoot))
			{
				return "ancestor is (or escapes) the large root";
			}
			if ((Object)(object)minimap.m_mapImageLarge != (Object)null && ((Component)minimap.m_mapImageLarge).transform.IsChildOf(candidate))
			{
				return "would hide the map image";
			}
			if ((Object)(object)minimap.m_sharedMapHint != (Object)null && minimap.m_sharedMapHint.transform.IsChildOf(candidate))
			{
				return "would hide the shared-map hint";
			}
			if (minimap.m_hints != null)
			{
				foreach (GameObject hint in minimap.m_hints)
				{
					if ((Object)(object)hint != (Object)null && hint.transform.IsChildOf(candidate))
					{
						return "would hide a bottom hint bar";
					}
				}
			}
			RectTransform val = ((PinRootLargeField != null) ? PinRootLargeField.Invoke(minimap) : null);
			if ((Object)(object)val != (Object)null && ((Transform)val).IsChildOf(candidate))
			{
				return "would hide the pin root";
			}
			RectTransform val2 = ((PinNameRootLargeField != null) ? PinNameRootLargeField.Invoke(minimap) : null);
			if ((Object)(object)val2 != (Object)null && ((Transform)val2).IsChildOf(candidate))
			{
				return "would hide the pin name root";
			}
			foreach (Transform item in otherGroup)
			{
				if (item.IsChildOf(candidate))
				{
					return "contains the other button group";
				}
			}
			return "";
		}

		public static void GetLargeMapProtectedRoots(out RectTransform? pinRoot, out RectTransform? pinNameRoot, out Transform? biomeLabel)
		{
			pinRoot = null;
			pinNameRoot = null;
			biomeLabel = null;
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				pinRoot = ((PinRootLargeField != null) ? PinRootLargeField.Invoke(instance) : null);
				pinNameRoot = ((PinNameRootLargeField != null) ? PinNameRootLargeField.Invoke(instance) : null);
				Text val = ((BiomeNameLargeField != null) ? BiomeNameLargeField.Invoke(instance) : null);
				biomeLabel = (((Object)(object)val != (Object)null) ? ((Component)val).transform : null);
			}
			catch
			{
			}
		}

		public static List<GameObject> GetSystemFilterButtons()
		{
			List<GameObject> list = new List<GameObject>();
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return list;
			}
			try
			{
				Image[] array = (Image[])(object)new Image[2] { instance.m_selectedIconDeath, instance.m_selectedIconBoss };
				foreach (Image val in array)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).transform.parent != (Object)null)
					{
						list.Add(((Component)((Component)val).transform.parent).gameObject);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		public static bool TryGetPinSprite(int vanillaType, out Sprite? sprite)
		{
			sprite = null;
			if (GetSpriteInvoker == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				object obj = GetSpriteInvoker.Invoke((object)Minimap.instance, new object[1] { (object)(PinType)vanillaType });
				sprite = (Sprite?)((obj is Sprite) ? obj : null);
				return (Object)(object)sprite != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		public static bool TryIsExplored(Vector3 world, out bool explored)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			explored = true;
			if (IsExploredInvoker == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				explored = (bool)IsExploredInvoker.Invoke((object)Minimap.instance, new object[1] { world });
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static FieldRef<Minimap, float>? BuildLargeZoomRef()
		{
			try
			{
				return AccessTools.FieldRefAccess<Minimap, float>("m_largeZoom");
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<Minimap, TField>? BuildFieldRef<TField>(string fieldName)
		{
			try
			{
				return AccessTools.FieldRefAccess<Minimap, TField>(fieldName);
			}
			catch
			{
				return null;
			}
		}

		public static bool TryScreenToWorldPoint(Vector3 screenPosition, out Vector3 worldPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			worldPosition = default(Vector3);
			if (ScreenToWorldInvoker == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			try
			{
				worldPosition = (Vector3)ScreenToWorldInvoker.Invoke((object)Minimap.instance, new object[1] { screenPosition });
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	internal sealed class OrphanChromeSweep
	{
		private const float SweepCooldownSeconds = 1f;

		private readonly List<GameObject> _hidden = new List<GameObject>();

		private float _nextSweepTime;

		public string LastDiagnostics { get; private set; } = "";

		public void Sweep(List<GameObject?> hiddenRailObjects)
		{
			if (Time.unscaledTime < _nextSweepTime)
			{
				return;
			}
			_nextSweepTime = Time.unscaledTime + 1f;
			try
			{
				Minimap instance = Minimap.instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_largeRoot == (Object)null)
				{
					return;
				}
				Transform transform = instance.m_largeRoot.transform;
				List<Transform> protectedRoots = CollectProtectedRoots(instance);
				StringBuilder stringBuilder = new StringBuilder();
				foreach (GameObject hiddenRailObject in hiddenRailObjects)
				{
					if ((Object)(object)hiddenRailObject == (Object)null || hiddenRailObject.activeSelf)
					{
						continue;
					}
					Transform parent = hiddenRailObject.transform.parent;
					Transform val = null;
					string text = "large root reached";
					int num = 0;
					while ((Object)(object)parent != (Object)null && num < 3)
					{
						if (!OrphanChromeRule.MayHide(GatherFacts(parent, transform, protectedRoots, out string keepReason)))
						{
							text = "'" + ((Object)parent).name + "': " + keepReason;
							break;
						}
						val = parent;
						parent = parent.parent;
						num++;
					}
					if ((Object)(object)val != (Object)null)
					{
						HideTracked(((Component)val).gameObject, stringBuilder);
					}
					else if (stringBuilder.Length == 0)
					{
						stringBuilder.Append("no orphan above '" + ((Object)hiddenRailObject).name + "' (" + text + ")");
					}
				}
				LastDiagnostics = ((stringBuilder.Length > 0) ? stringBuilder.ToString() : "nothing to hide");
			}
			catch (Exception exception)
			{
				LastDiagnostics = "sweep failed: " + SafeLogText.Brief(exception);
			}
		}

		public void RestoreAll()
		{
			foreach (GameObject item in _hidden)
			{
				if ((Object)(object)item != (Object)null && !item.activeSelf)
				{
					item.SetActive(true);
				}
			}
			if (_hidden.Count > 0)
			{
				_hidden.Clear();
				LastDiagnostics = "";
				_nextSweepTime = 0f;
			}
		}

		private void HideTracked(GameObject chrome, StringBuilder summary)
		{
			bool flag = false;
			foreach (GameObject item in _hidden)
			{
				if (item == chrome)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				_hidden.Add(chrome);
			}
			if (chrome.activeSelf)
			{
				chrome.SetActive(false);
			}
			string value = "hid '" + ((Object)chrome).name + "'";
			if (!summary.ToString().Contains(value))
			{
				if (summary.Length > 0)
				{
					summary.Append("; ");
				}
				summary.Append(value);
			}
		}

		private static List<Transform> CollectProtectedRoots(Minimap minimap)
		{
			List<Transform> list = new List<Transform>();
			if ((Object)(object)minimap.m_mapImageLarge != (Object)null)
			{
				list.Add(((Component)minimap.m_mapImageLarge).transform);
			}
			if ((Object)(object)minimap.m_sharedMapHint != (Object)null)
			{
				list.Add(minimap.m_sharedMapHint.transform);
			}
			if (minimap.m_hints != null)
			{
				foreach (GameObject hint in minimap.m_hints)
				{
					if ((Object)(object)hint != (Object)null)
					{
						list.Add(hint.transform);
					}
				}
			}
			MinimapReflection.GetLargeMapProtectedRoots(out RectTransform pinRoot, out RectTransform pinNameRoot, out Transform biomeLabel);
			if ((Object)(object)pinRoot != (Object)null)
			{
				list.Add((Transform)(object)pinRoot);
			}
			if ((Object)(object)pinNameRoot != (Object)null)
			{
				list.Add((Transform)(object)pinNameRoot);
			}
			if ((Object)(object)biomeLabel != (Object)null)
			{
				list.Add(biomeLabel);
			}
			return list;
		}

		private static OrphanChromeRule.CandidateFacts GatherFacts(Transform candidate, Transform largeRoot, List<Transform> protectedRoots, out string keepReason)
		{
			keepReason = "";
			bool flag = (Object)(object)candidate == (Object)(object)largeRoot || !candidate.IsChildOf(largeRoot);
			if (flag)
			{
				keepReason = "is (or escapes) the large root";
			}
			bool flag2 = false;
			if (!flag)
			{
				foreach (Transform protectedRoot in protectedRoots)
				{
					if ((Object)(object)protectedRoot != (Object)null && ((Object)(object)protectedRoot == (Object)(object)candidate || protectedRoot.IsChildOf(candidate)))
					{
						flag2 = true;
						keepReason = "contains protected '" + ((Object)protectedRoot).name + "'";
						break;
					}
				}
			}
			bool flag3 = false;
			bool hasLiveTextGraphic = false;
			if (!flag && !flag2)
			{
				Selectable[] componentsInChildren = ((Component)candidate).GetComponentsInChildren<Selectable>(true);
				foreach (Selectable val in componentsInChildren)
				{
					if (WouldBeVisibleUnder(candidate, ((Component)val).transform))
					{
						flag3 = true;
						keepReason = "contains live control '" + ((Object)val).name + "'";
						break;
					}
				}
				if (!flag3)
				{
					Graphic[] componentsInChildren2 = ((Component)candidate).GetComponentsInChildren<Graphic>(true);
					foreach (Graphic val2 in componentsInChildren2)
					{
						if (!(val2 is Image) && !(val2 is RawImage) && WouldBeVisibleUnder(candidate, ((Component)val2).transform))
						{
							hasLiveTextGraphic = true;
							keepReason = "contains text '" + ((Object)val2).name + "'";
							break;
						}
					}
				}
			}
			return new OrphanChromeRule.CandidateFacts(flag, flag2, flag3, hasLiveTextGraphic);
		}

		private static bool WouldBeVisibleUnder(Transform candidate, Transform element)
		{
			Transform val = element;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)candidate)
			{
				if (!((Component)val).gameObject.activeSelf)
				{
					return false;
				}
				val = val.parent;
			}
			return true;
		}
	}
	internal sealed class OverlayPanelRelabel
	{
		private const string OriginalLabel = "Mod Overlays";

		private const string ReplacementLabel = "Map Overlays";

		private readonly ManualLogSource _log;

		private readonly List<(Text Label, string Original)> _renamed = new List<(Text, string)>();

		private bool _missingLogged;

		public OverlayPanelRelabel(ManualLogSource log)
		{
			_log = log;
		}

		public void EnsureApplied()
		{
			try
			{
				_renamed.RemoveAll(((Text Label, string Original) entry) => (Object)(object)entry.Label == (Object)null);
				Minimap instance = Minimap.instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_mapLarge == (Object)null)
				{
					return;
				}
				Transform val = FindOverlayPanel(instance.m_mapLarge.transform);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				bool flag = false;
				Text[] componentsInChildren = ((Component)val).GetComponentsInChildren<Text>(true);
				foreach (Text val2 in componentsInChildren)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						string a = val2.text?.Trim() ?? string.Empty;
						if (string.Equals(a, "Map Overlays", StringComparison.Ordinal))
						{
							flag = true;
						}
						else if (string.Equals(a, "Mod Overlays", StringComparison.Ordinal))
						{
							_renamed.Add((val2, val2.text));
							val2.text = "Map Overlays";
							flag = true;
						}
					}
				}
				if (!flag && !_missingLogged)
				{
					_missingLogged = true;
					_log.LogInfo((object)"The Jötunn overlay panel does not carry the expected 'Mod Overlays' label; leaving its wording untouched.");
				}
			}
			catch (Exception exception)
			{
				_missingLogged = true;
				_log.LogWarning((object)("Could not rename the overlay panel label: " + SafeLogText.Brief(exception)));
			}
		}

		public void Restore()
		{
			foreach (var (val, text) in _renamed)
			{
				try
				{
					if ((Object)(object)val != (Object)null)
					{
						val.text = text;
					}
				}
				catch
				{
				}
			}
			_renamed.Clear();
		}

		private static Transform? FindOverlayPanel(Transform mapLarge)
		{
			for (int i = 0; i < mapLarge.childCount; i++)
			{
				Transform child = mapLarge.GetChild(i);
				if ((Object)(object)child != (Object)null && ((Object)child).name.StartsWith("MinimapOverlayPanel", StringComparison.Ordinal))
				{
					return child;
				}
			}
			return null;
		}
	}
	internal sealed class OverlayUserToggleHook
	{
		private static readonly FieldInfo? ToggleField = AccessTools.Field(typeof(MapOverlayBase), "Toggle");

		private Toggle? _hooked;

		public void Maintain(MapOverlayBase overlay, bool userState, Action<bool> onUserToggled)
		{
			if ((object)ToggleField == null)
			{
				return;
			}
			Toggle val;
			try
			{
				object? value = ToggleField.GetValue(overlay);
				val = (Toggle)((value is Toggle) ? value : null);
			}
			catch
			{
				return;
			}
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)_hooked))
			{
				_hooked = val;
				((UnityEvent<bool>)(object)val.onValueChanged).AddListener((UnityAction<bool>)delegate(bool obj2)
				{
					onUserToggled(obj2);
				});
				val.SetIsOnWithoutNotify(userState);
			}
		}

		public void SyncCheckbox(bool userState)
		{
			if ((Object)(object)_hooked != (Object)null && _hooked.isOn != userState)
			{
				_hooked.SetIsOnWithoutNotify(userState);
			}
		}
	}
	internal sealed class PinAdapter
	{
		private static readonly FieldRef<Minimap, List<PinData>>? PinsField = BuildPinsFieldRef();

		private static readonly int[] PlaceableTypes = new int[5] { 0, 1, 2, 3, 6 };

		private readonly ManualLogSource _log;

		private readonly PinRenderingLedger<PinData> _ledger = new PinRenderingLedger<PinData>(ReadRenderingState);

		private readonly Dictionary<PinData, string> _customSpriteByRendering = new Dictionary<PinData, string>();

		private bool _disabledForSession;

		private bool _sessionBound;

		private int _spriteRebinds;

		public bool IsOperational
		{
			get
			{
				if (!_disabledForSession)
				{
					return PinsField != null;
				}
				return false;
			}
		}

		public bool NeedsRebind { get; private set; }

		public PinAdapter(ManualLogSource log)
		{
			_log = log;
		}

		public void Reset()
		{
			_ledger.Reset();
			_customSpriteByRendering.Clear();
			_disabledForSession = false;
			_sessionBound = false;
		}

		public List<PinData> ListAdoptable()
		{
			List<PinData> list = new List<PinData>();
			if (!TryGetPins(out List<PinData> pins))
			{
				return list;
			}
			foreach (PinData item in pins)
			{
				if (IsAdoptableVanilla(item))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public AtlasPin? Adopt(PinStore store, PinData source)
		{
			if (_disabledForSession || !IsAdoptableVanilla(source))
			{
				return null;
			}
			try
			{
				AtlasPin atlasPin = store.Create(delegate(AtlasPin pin)
				{
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Expected I4, but got Unknown
					pin.Name = source.m_name ?? "";
					pin.IconId = IconRegistry.FromVanillaType((int)source.m_type);
					pin.Checked = source.m_checked;
					pin.Source = AtlasPinSource.AdoptedVanilla;
					pin.Position = new RoadPoint(source.m_pos.x, source.m_pos.y, source.m_pos.z);
				});
				_ledger.Track(source, atlasPin.Id);
				return atlasPin;
			}
			catch (Exception exception)
			{
				Disable(exception);
				return null;
			}
		}

		public void ReconcileOnMapReady(PinStore store, string reason = "map-available")
		{
			_disabledForSession = false;
			try
			{
				Reset();
				_spriteRebinds = 0;
				if (!TryGetPins(out List<PinData> pins))
				{
					return;
				}
				List<PinData> list = new List<PinData>();
				foreach (PinData item in pins)
				{
					if (IsAdoptableVanilla(item))
					{
						list.Add(item);
					}
				}
				Minimap instance = Minimap.instance;
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				foreach (AtlasPin item2 in store.All)
				{
					PinData val = _ledger.ClaimMatch(list, item2);
					if (item2.Deleted || item2.Archived)
					{
						if (val != null)
						{
							RemoveRenderingFromMap(instance, val);
							num3++;
						}
					}
					else if (val != null)
					{
						_ledger.Track(val, item2.Id);
						num++;
						SyncPin(store, item2.Id);
					}
					else
					{
						AddManagedPin(item2);
						num2++;
					}
				}
				if (!_disabledForSession)
				{
					_sessionBound = true;
					NeedsRebind = false;
				}
				_log.LogInfo((object)($"Pin reconcile ({reason}): linked {_ledger.TrackedCount} managed pin(s) " + $"(claimed {num}, added {num2}), removed {num3} stale rendering(s), " + $"custom sprite rebinds {_spriteRebinds}."));
			}
			catch (Exception exception)
			{
				Disable(exception);
			}
		}

		public void SyncPin(PinStore store, AtlasId id)
		{
			if (_disabledForSession)
			{
				return;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				if (!store.TryGet(id, out AtlasPin pin))
				{
					return;
				}
				int wantedVanillaType = IconRegistry.ResolveVanillaType(pin.IconId);
				PinData existing;
				switch (_ledger.DecideSync(pin, wantedVanillaType, out existing))
				{
				case PinRenderingLedger<PinData>.SyncDecision.Add:
					AddManagedPin(pin);
					break;
				case PinRenderingLedger<PinData>.SyncDecision.Remove:
					RemoveRenderingFromMap(instance, existing);
					ForgetRendering(existing);
					break;
				case PinRenderingLedger<PinData>.SyncDecision.Replace:
					RemoveRenderingFromMap(instance, existing);
					ForgetRendering(existing);
					AddManagedPin(pin);
					break;
				case PinRenderingLedger<PinData>.SyncDecision.UpdateChecked:
					existing.m_checked = pin.Checked;
					EnsureCustomSprite(existing, pin);
					break;
				case PinRenderingLedger<PinData>.SyncDecision.None:
					if (existing != null && !pin.Deleted && !pin.Archived)
					{
						EnsureCustomSprite(existing, pin);
					}
					break;
				}
			}
			catch (Exception exception)
			{
				Disable(exception);
			}
		}

		public void SyncAllPins(PinStore store, Func<AtlasPin, bool>? skipRendering = null)
		{
			if (_disabledForSession)
			{
				return;
			}
			foreach (AtlasPin item in store.All)
			{
				if (skipRendering == null || item.Deleted || item.Archived || !skipRendering(item))
				{
					SyncPin(store, item.Id);
					if (_disabledForSession)
					{
						break;
					}
				}
			}
		}

		public void AbsorbVanillaChanges(PinStore store)
		{
			if (_disabledForSession || _ledger.TrackedCount == 0)
			{
				return;
			}
			try
			{
				if (!TryGetPins(out List<PinData> pins))
				{
					return;
				}
				HashSet<PinData> hashSet = new HashSet<PinData>(pins);
				List<PinData> list = new List<PinData>();
				foreach (KeyValuePair<PinData, AtlasId> item in _ledger.Tracked)
				{
					AtlasPin pin;
					if (!hashSet.Contains(item.Key))
					{
						list.Add(item.Key);
					}
					else if (store.TryGet(item.Value, out pin) && pin.Checked != item.Key.m_checked)
					{
						bool nowChecked = item.Key.m_checked;
						store.Mutate(item.Value, delegate(AtlasPin atlasPin)
						{
							atlasPin.Checked = nowChecked;
						});
					}
				}
				if (list.Count <= 0)
				{
					return;
				}
				foreach (PinData item2 in list)
				{
					ForgetRendering(item2);
				}
				NeedsRebind = true;
				_sessionBound = false;
				_log.LogInfo((object)($"Pin lifecycle: {list.Count} tracked rendering(s) disappeared without an explicit " + "vanilla delete (map rebuild assumed); no tombstones written, markers will rebind."));
			}
			catch (Exception exception)
			{
				Disable(exception);
			}
		}

		public void HandleExplicitVanillaDelete(PinStore store, PinData pin)
		{
			if (_disabledForSession || pin == null)
			{
				return;
			}
			try
			{
				if (_ledger.TryGetId(pin, out var id) && store.TryGet(id, out AtlasPin pin2))
				{
					if (PinTombstoneRule.Decide(explicitVanillaDelete: true, _sessionBound, pin2.Deleted) == PinTombstoneRule.Verdict.Tombstone)
					{
						store.Delete(id);
						ForgetRendering(pin);
						_log.LogInfo((object)"Pin lifecycle: managed pin tombstoned (cause: explicit vanilla delete in a bound map session).");
					}
					else
					{
						ForgetRendering(pin);
						NeedsRebind = true;
						_log.LogInfo((object)"Pin lifecycle: vanilla delete observed outside a bound map session; kept the atlas entry and will rebind.");
					}
				}
			}
			catch (Exception exception)
			{
				Disable(exception);
			}
		}

		public void DisplayHide(AtlasId id)
		{
			if (_disabledForSession)
			{
				return;
			}
			try
			{
				if (_ledger.TryGetRendering(id, out PinData rendering))
				{
					ForgetRendering(rendering);
					Minimap instance = Minimap.instance;
					if ((Object)(object)instance != (Object)null)
					{
						RemoveRenderingFromMap(instance, rendering);
					}
				}
			}
			catch (Exception exception)
			{
				Disable(exception);
			}
		}

		public bool TryGetManagedId(PinData pin, out AtlasId id)
		{
			return _ledger.TryGetId(pin, out id);
		}

		public bool ContainsPin(PinData pin)
		{
			if (TryGetPins(out List<PinData> pins))
			{
				return pins.Contains(pin);
			}
			return false;
		}

		public PinData? TryFindAdoptableAt(Vector3 position, string preferredName)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			PinData val = null;
			foreach (PinData item in ListAdoptable())
			{
				float num = item.m_pos.x - position.x;
				float num2 = item.m_pos.z - position.z;
				if (!(num * num + num2 * num2 > 0.25f))
				{
					if (string.Equals(item.m_name ?? "", preferredName, StringComparison.Ordinal))
					{
						return item;
					}
					if (val == null)
					{
						val = item;
					}
				}
			}
			return val;
		}

		public bool TryFindNearest(Vector3 position, float maxRadius, out PinData pin, out float distance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			pin = null;
			distance = float.MaxValue;
			if (!TryGetPins(out List<PinData> pins))
			{
				return false;
			}
			foreach (PinData item in pins)
			{
				float num = Vector2.Distance(new Vector2(item.m_pos.x, item.m_pos.z), new Vector2(position.x, position.z));
				if (num < distance)
				{
					distance = num;
					pin = item;
				}
			}
			if (pin != null)
			{
				return distance <= maxRadius;
			}
			return false;
		}

		public bool IsAdoptableVanilla(PinData pin)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected I4, but got Unknown
			if (pin != null && pin.m_save && pin.m_ownerID == 0L && !_ledger.IsTracked(pin))
			{
				return Array.IndexOf(PlaceableTypes, (int)pin.m_type) >= 0;
			}
			return false;
		}

		public bool IsForeign(PinData pin)
		{
			if (!_ledger.IsTracked(pin))
			{
				return !IsAdoptableVanilla(pin);
			}
			return false;
		}

		private void AddManagedPin(AtlasPin managed)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			Minimap instance = Minimap.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(managed.Position.X, managed.Position.Y, managed.Position.Z);
				PinType val2 = (PinType)IconRegistry.ResolveVanillaType(managed.IconId);
				PinData val3 = instance.AddPin(val, val2, managed.Name, true, managed.Checked, 0L, default(PlatformUserID));
				_ledger.Track(val3, managed.Id);
				ApplyImmediateSprite(val3, managed.IconId);
			}
		}

		public void ApplyImmediateSprite(PinData pin, string iconId)
		{
			try
			{
				if (pin != null && CcIconSprites.TryGet(iconId, out Sprite sprite))
				{
					if (pin.m_icon != sprite)
					{
						pin.m_icon = sprite;
						_customSpriteByRendering[pin] = iconId;
					}
					if ((Object)(object)pin.m_iconElement != (Object)null && pin.m_iconElement.sprite != sprite)
					{
						pin.m_iconElement.sprite = sprite;
					}
				}
			}
			catch
			{
			}
		}

		private void EnsureCustomSprite(PinData rendering, AtlasPin managed)
		{
			Sprite sprite;
			string text = (CcIconSprites.TryGet(managed.IconId, out sprite) ? managed.IconId : null);
			string value;
			string text2 = (_customSpriteByRendering.TryGetValue(rendering, out value) ? value : null);
			if (text != null && text2 == null && (Object)(object)sprite != (Object)null && rendering.m_icon == sprite)
			{
				_customSpriteByRendering[rendering] = text;
			}
			else if (SpriteRebindRule.MustRebuild(text, text2, (Object)(object)rendering.m_icon != (Object)null))
			{
				Minimap instance = Minimap.instance;
				if (!((Object)(object)instance == (Object)null))
				{
					RemoveRenderingFromMap(instance, rendering);
					ForgetRendering(rendering);
					AddManagedPin(managed);
					_spriteRebinds++;
				}
			}
		}

		private static void RemoveRenderingFromMap(Minimap map, PinData rendering)
		{
			using (PinDeletionWatch.BeginSelfRemoval())
			{
				map.RemovePin(rendering);
			}
		}

		private void ForgetRendering(PinData rendering)
		{
			_ledger.Untrack(rendering);
			_customSpriteByRendering.Remove(rendering);
		}

		private static PinRenderingLedger<PinData>.RenderingState ReadRenderingState(PinData pin)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			return new PinRenderingLedger<PinData>.RenderingState(pin.m_name ?? "", pin.m_pos.x, pin.m_pos.y, pin.m_pos.z, (int)pin.m_type, pin.m_checked);
		}

		private bool TryGetPins(out List<PinData> pins)
		{
			pins = null;
			if (PinsField == null || (Object)(object)Minimap.instance == (Object)null)
			{
				return false;
			}
			pins = PinsField.Invoke(Minimap.instance);
			return pins != null;
		}

		private void Disable(Exception exception)
		{
			_disabledForSession = true;
			_sessionBound = false;
			_log.LogError((object)("Pin adapter failed and was disabled for this session (store data is safe): " + SafeLogText.Describe(exception)));
		}

		private static FieldRef<Minimap, List<PinData>>? BuildPinsFieldRef()
		{
			try
			{
				return AccessTools.FieldRefAccess<Minimap, List<PinData>>("m_pins");
			}
			catch
			{
				return null;
			}
		}
	}
	internal static class PinDeletionWatch
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public readonly struct SelfRemovalScope : IDisposable
		{
			public void Dispose()
			{
				if (_selfDepth > 0)
				{
					_selfDepth--;
				}
			}
		}

		public static Action<PinData>? ExplicitDelete;

		private static Harmony? _harmony;

		private static int _selfDepth;

		public static bool Installed { get; private set; }

		public static void Install(ManualLogSource log)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			if (Installed)
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(Minimap), "RemovePin", new Type[1] { typeof(PinData) }, (Type[])null);
				if ((object)methodInfo == null)
				{
					log.LogWarning((object)"Vanilla pin-delete detection unavailable (Minimap.RemovePin(PinData) not found); vanilla-deleted managed markers will be restored by the atlas instead of tombstoned.");
					return;
				}
				_harmony = new Harmony("com.theconcernedcat.valheim.concernedcartographer.pindeletion");
				_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PinDeletionWatch), "BeforeRemovePin", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Installed = true;
			}
			catch (Exception exception)
			{
				log.LogWarning((object)("Vanilla pin-delete detection unavailable (" + SafeLogText.Brief(exception) + "); vanilla-deleted managed markers will be restored by the atlas instead of tombstoned."));
				_harmony = null;
			}
		}

		public static void Uninstall()
		{
			try
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
			_harmony = null;
			Installed = false;
			ExplicitDelete = null;
			_selfDepth = 0;
		}

		public static SelfRemovalScope BeginSelfRemoval()
		{
			_selfDepth++;
			return default(SelfRemovalScope);
		}

		private static void BeforeRemovePin(PinData pin)
		{
			try
			{
				if (_selfDepth == 0 && pin != null)
				{
					ExplicitDelete?.Invoke(pin);
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class PinDisplayController
	{
		private const float WorldTierZoom = 0.5f;

		private const float RegionalTierZoom = 0.2f;

		private const float WorldTierCellMeters = 256f;

		private const float RegionalTierCellMeters = 96f;

		private readonly ManualLogSource _log;

		private readonly List<PinData> _clusterMarkers = new List<PinData>();

		private readonly HashSet<Guid> _displayHidden = new HashSet<Guid>();

		private readonly HashSet<Guid> _stickyVisible = new HashSet<Guid>();

		private bool _disabledForSession;

		private int _lastTier = -1;

		public string QueryText { get; private set; } = "";

		public bool ShowPins { get; set; } = true;

		public bool ClusterEnabled { get; set; } = true;

		public int VisibleCount { get; private set; }

		public int HiddenByFilter { get; private set; }

		public int ClusterCount { get; private set; }

		public PinDisplayController(ManualLogSource log)
		{
			_log = log;
		}

		public void SetQuery(string text)
		{
			QueryText = text ?? "";
		}

		public bool IsDisplayHidden(AtlasPin pin)
		{
			return _displayHidden.Contains(pin.Id.Value);
		}

		public void MarkStickyVisible(AtlasId id)
		{
			_stickyVisible.Add(id.Value);
		}

		public void Apply(PinStore store, PinAdapter adapter)
		{
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			if (_disabledForSession)
			{
				return;
			}
			Minimap instance = Minimap.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				ClearClusterMarkers();
				PinQuery pinQuery = PinQuery.Parse(QueryText);
				List<AtlasPin> list = new List<AtlasPin>();
				HiddenByFilter = 0;
				foreach (AtlasPin item in store.Living)
				{
					if (!item.Archived)
					{
						bool flag = _stickyVisible.Contains(item.Id.Value);
						if (!ShowPins || (!flag && !pinQuery.IsEmpty && !pinQuery.Matches(item)))
						{
							HiddenByFilter++;
						}
						else
						{
							list.Add(item);
						}
					}
				}
				float cellMeters = 0f;
				if (ClusterEnabled && MinimapReflection.TryGetLargeZoom(out var zoom))
				{
					cellMeters = ((zoom >= 0.5f) ? 256f : ((zoom >= 0.2f) ? 96f : 0f));
				}
				PinClusterer.Result result = PinClusterer.Compute(list, cellMeters, 3, (_stickyVisible.Count > 0) ? _stickyVisible : null);
				HashSet<Guid> hashSet = new HashSet<Guid>();
				foreach (AtlasPin single in result.Singles)
				{
					hashSet.Add(single.Id.Value);
				}
				foreach (AtlasPin item2 in store.Living)
				{
					if (!item2.Archived)
					{
						bool flag2 = hashSet.Contains(item2.Id.Value);
						bool flag3 = _displayHidden.Contains(item2.Id.Value);
						if (flag2 && flag3)
						{
							_displayHidden.Remove(item2.Id.Value);
							adapter.SyncPin(store, item2.Id);
						}
						else if (!flag2 && !flag3)
						{
							_displayHidden.Add(item2.Id.Value);
							adapter.DisplayHide(item2.Id);
						}
					}
				}
				Vector3 val = default(Vector3);
				foreach (PinClusterer.Cluster cluster in result.Clusters)
				{
					string text = ((cluster.DominantCategory.Length > 0) ? $"{cluster.Members.Count} × {cluster.DominantCategory}" : $"{cluster.Members.Count} pins");
					((Vector3)(ref val))..ctor(cluster.Center.X, 0f, cluster.Center.Z);
					PinType val2 = (PinType)IconRegistry.ResolveVanillaType(cluster.DominantIconId);
					PinData val3 = instance.AddPin(val, val2, text, false, false, 0L, default(PlatformUserID));
					if (CcIconSprites.TryGet(cluster.DominantIconId, out Sprite sprite))
					{
						val3.m_icon = sprite;
						if ((Object)(object)val3.m_iconElement != (Object)null)
						{
							val3.m_iconElement.sprite = sprite;
						}
					}
					_clusterMarkers.Add(val3);
				}
				VisibleCount = result.Singles.Count;
				ClusterCount = result.Clusters.Count;
			}
			catch (Exception exception)
			{
				Disable(store, exception);
			}
		}

		public bool ZoomTierChanged()
		{
			if (!ClusterEnabled || !MinimapReflection.TryGetLargeZoom(out var zoom))
			{
				return false;
			}
			int num = ((zoom >= 0.5f) ? 2 : ((zoom >= 0.2f) ? 1 : 0));
			if (num == _lastTier)
			{
				return false;
			}
			_stickyVisible.Clear();
			_lastTier = num;
			return true;
		}

		public void Reset()
		{
			ClearClusterMarkers();
			_displayHidden.Clear();
			_stickyVisible.Clear();
			_lastTier = -1;
			VisibleCount = 0;
			HiddenByFilter = 0;
			ClusterCount = 0;
			_disabledForSession = false;
		}

		private void ClearClusterMarkers()
		{
			foreach (PinData clusterMarker in _clusterMarkers)
			{
				try
				{
					Minimap instance = Minimap.instance;
					if (instance != null)
					{
						instance.RemovePin(clusterMarker);
					}
				}
				catch
				{
				}
			}
			_clusterMarkers.Clear();
			ClusterCount = 0;
		}

		private void Disable(PinStore store, Exception exception)
		{
			_disabledForSession = true;
			_log.LogError((object)("Pin display controller failed and was disabled for this session (all pins will render plainly): " + SafeLogText.Describe(exception)));
			try
			{
				ClearClusterMarkers();
				_displayHidden.Clear();
			}
			catch
			{
			}
		}
	}
	internal sealed class PinPalettePanel
	{
		private const float PanelWidth = 232f;

		private const float PanelHeight = 560f;

		private const float RowHeight = 24f;

		private const float RowWidth = 192f;

		private const float ListTop = 108f;

		private const float ListBottomMargin = 18f;

		private const int MaxRecents = 3;

		private readonly ManualLogSource _log;

		private GameObject? _panel;

		private InputField? _search;

		private Text? _status;

		private GameObject? _listRoot;

		private ScrollRect? _scroll;

		private string? _selectedIconId;

		private readonly List<string> _recents = new List<string>();

		private readonly HashSet<string> _collapsedCategories = new HashSet<string>();

		private bool _failed;

		public Action<IconRegistry.IconDefinition>? IconChosen;

		public Action? SelectionCleared;

		public float UiScale = 1f;

		public string? SelectedIconId => _selectedIconId;

		public GameObject? PanelObject => _panel;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public bool HasFailed => _failed;

		public PinPalettePanel(ManualLogSource log)
		{
			_log = log;
		}

		public void EnsureBuilt()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Expected O, but got Unknown
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Expected O, but got Unknown
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			if (_failed || (Object)(object)_panel != (Object)null)
			{
				return;
			}
			try
			{
				GameObject val = (((Object)(object)Minimap.instance != (Object)null) ? Minimap.instance.m_largeRoot : null);
				if ((Object)(object)val == (Object)null || !val.activeInHierarchy || GUIManager.Instance == null)
				{
					return;
				}
				GUIManager instance = GUIManager.Instance;
				_panel = instance.CreateWoodpanel(val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(0f - 232f * UiScale / 2f - 30f, 0f), 232f, 560f, true);
				_panel.transform.localScale = Vector3.one * UiScale;
				_panel.SetActive(false);
				Font averiaSerifBold = instance.AveriaSerifBold;
				Color val2 = default(Color);
				((Color)(ref val2))..ctor(0.9f, 0.8f, 0.6f, 1f);
				instance.CreateText(AtlasStrings.Get("palette.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -22f), averiaSerifBold, 16, val2, true, Color.black, 208f, 26f, false);
				GameObject val3 = instance.CreateInputField(_panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -50f), (ContentType)0, AtlasStrings.Get("palette.search"), 13, 192f, 26f);
				_search = val3.GetComponent<InputField>();
				((UnityEvent<string>)(object)_search.onValueChanged).AddListener((UnityAction<string>)delegate
				{
					RebuildList();
				});
				_status = instance.CreateText(AtlasStrings.Get("palette.pick"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -80f), averiaSerifBold, 11, Color.white, false, Color.black, 192f, 30f, false).GetComponent<Text>();
				_status.alignment = (TextAnchor)1;
				float num = 434f;
				GameObject obj = instance.CreateScrollView(_panel.transform, false, true, 8f, 2f, GUIManager.Instance.ValheimScrollbarHandleColorBlock, new Color(0f, 0f, 0f, 0.35f), 212f, num);
				RectTransform val4 = (RectTransform)obj.transform;
				val4.anchorMin = new Vector2(0.5f, 1f);
				val4.anchorMax = new Vector2(0.5f, 1f);
				val4.pivot = new Vector2(0.5f, 1f);
				val4.anchoredPosition = new Vector2(0f, -108f);
				Transform val5 = obj.transform.Find("Scroll View");
				_scroll = (((Object)(object)val5 != (Object)null) ? ((Component)val5).GetComponent<ScrollRect>() : null);
				if ((Object)(object)_scroll == (Object)null)
				{
					throw new InvalidOperationException("Jötunn scroll view layout changed; palette cannot build.");
				}
				_scroll.scrollSensitivity = PaletteScrollTuning.Scaled(_scroll.scrollSensitivity);
				Image component = ((Component)val5).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = new Color(0f, 0f, 0f, 0.25f);
				}
				GameObject val6 = (((Object)(object)_scroll.content != (Object)null) ? ((Component)_scroll.content).gameObject : null);
				if ((Object)(object)val6 == (Object)null)
				{
					Transform val7 = val5.Find("Viewport/Content");
					if (!((Object)(object)val7 != (Object)null))
					{
						throw new InvalidOperationException("Jötunn scroll view content missing; palette cannot build.");
					}
					val6 = ((Component)val7).gameObject;
					_scroll.content = (RectTransform)val7;
				}
				LayoutGroup[] components = val6.GetComponents<LayoutGroup>();
				for (int num2 = 0; num2 < components.Length; num2++)
				{
					Object.DestroyImmediate((Object)(object)components[num2]);
				}
				ContentSizeFitter component2 = val6.GetComponent<ContentSizeFitter>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)component2);
				}
				RectTransform val8 = (RectTransform)val6.transform;
				val8.anchorMin = new Vector2(0f, 1f);
				val8.anchorMax = new Vector2(1f, 1f);
				val8.pivot = new Vector2(0.5f, 1f);
				val8.offsetMin = new Vector2(0f, val8.offsetMin.y);
				val8.offsetMax = new Vector2(0f, val8.offsetMax.y);
				_listRoot = val6;
				RebuildList();
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Toggle()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(!_panel.activeSelf);
			}
		}

		public void Hide()
		{
			if ((Object)(object)_panel != (Object)null && _panel.activeSelf)
			{
				_panel.SetActive(false);
			}
		}

		public void HandleFrame()
		{
			if (IsVisible && Input.GetKeyDown((KeyCode)27) && !CcTextFocus.EscapeShouldOnlyBlur())
			{
				Hide();
			}
		}

		public void SetUnavailable()
		{
			Hide();
			if (_selectedIconId != null)
			{
				_selectedIconId = null;
				SelectionCleared?.Invoke();
			}
		}

		public void NoteUsed(string iconId)
		{
			_recents.Remove(iconId);
			_recents.Insert(0, iconId);
			while (_recents.Count > 3)
			{
				_recents.RemoveAt(_recents.Count - 1);
			}
			if ((Object)(object)_panel != (Object)null)
			{
				RebuildList();
			}
		}

		public void Reset()
		{
			_panel = null;
			_search = null;
			_status = null;
			_listRoot = null;
			_scroll = null;
		}

		private void RebuildList()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_listRoot == (Object)null)
			{
				return;
			}
			try
			{
				foreach (Transform item in _listRoot.transform)
				{
					((Component)item).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				GUIManager instance = GUIManager.Instance;
				Font averiaSerifBold = instance.AveriaSerifBold;
				Color color = default(Color);
				((Color)(ref color))..ctor(0.8f, 0.7f, 0.5f, 1f);
				float y = -4f;
				string text = (((Object)(object)_search != (Object)null) ? _search.text.Trim() : "");
				if (text.Length == 0)
				{
					List<IconRegistry.IconDefinition> list = new List<IconRegistry.IconDefinition>();
					foreach (string recent in _recents)
					{
						if (IconRegistry.TryResolve(recent, out IconRegistry.IconDefinition definition))
						{
							list.Add(definition);
						}
					}
					if (list.Count > 0)
					{
						AddHeader(instance, averiaSerifBold, color, AtlasStrings.Get("palette.recent"), ref y);
						foreach (IconRegistry.IconDefinition item2 in list)
						{
							AddIconRow(instance, item2, ref y);
						}
					}
					List<string> list2 = new List<string>();
					foreach (IconRegistry.IconDefinition item3 in IconRegistry.All)
					{
						if (!list2.Contains(item3.DefaultCategory))
						{
							list2.Add(item3.DefaultCategory);
						}
					}
					foreach (string item4 in list2)
					{
						int num = 0;
						foreach (IconRegistry.IconDefinition item5 in IconRegistry.All)
						{
							if (item5.DefaultCategory == item4)
							{
								num++;
							}
						}
						bool flag = _collapsedCategories.Contains(item4);
						AddCategoryHeader(instance, item4, num, flag, ref y);
						if (flag)
						{
							continue;
						}
						foreach (IconRegistry.IconDefinition item6 in IconRegistry.All)
						{
							if (item6.DefaultCategory == item4)
							{
								AddIconRow(instance, item6, ref y);
							}
						}
					}
				}
				else
				{
					foreach (IconRegistry.IconDefinition item7 in IconRegistry.Search(text))
					{
						AddIconRow(instance, item7, ref y);
					}
				}
				RectTransform val2 = (RectTransform)_listRoot.transform;
				val2.sizeDelta = new Vector2(val2.sizeDelta.x, Mathf.Max(0f - y + 6f, 10f));
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void AddHeader(GUIManager gui, Font font, Color color, string text, ref float y)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			gui.CreateText(text, _listRoot.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), font, 11, color, false, Color.black, 192f, 16f, false).GetComponent<Text>().alignment = (TextAnchor)4;
			y -= 18f;
		}

		private void AddCategoryHeader(GUIManager gui, string category, int count, bool collapsed, ref float y)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = gui.CreateButton(string.Format("{0} {1} ({2})", collapsed ? "▸" : "▾", category, count), _listRoot.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), 192f, 20f);
			Text componentInChildren = obj.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = 11;
				((Graphic)componentInChildren).color = new Color(0.85f, 0.75f, 0.55f, 1f);
			}
			((UnityEvent)obj.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				if (!_collapsedCategories.Remove(category))
				{
					_collapsedCategories.Add(category);
				}
				RebuildList();
			});
			y -= 23f;
		}

		private void AddIconRow(GUIManager gui, IconRegistry.IconDefinition definition, ref float y)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			bool flag = string.Equals(definition.Id, _selectedIconId, StringComparison.Ordinal);
			GameObject val = gui.CreateButton((flag ? "» " : "") + definition.DisplayName, _listRoot.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), 192f, 24f);
			Sprite sprite2;
			Sprite sprite = (CcIconSprites.TryGet(definition.Id, out sprite2) ? sprite2 : null);
			if ((Object)(object)sprite != (Object)null || MinimapReflection.TryGetPinSprite(definition.VanillaType, out sprite))
			{
				GameObject val2 = new GameObject("CCPalettePreview", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val2.transform.SetParent(val.transform, false);
				RectTransform val3 = (RectTransform)val2.transform;
				val3.anchorMin = new Vector2(0f, 0.5f);
				val3.anchorMax = new Vector2(0f, 0.5f);
				val3.anchoredPosition = new Vector2(14f, 0f);
				val3.sizeDelta = new Vector2(18f, 18f);
				Image component = val2.GetComponent<Image>();
				component.sprite = sprite;
				component.preserveAspect = true;
				((Graphic)component).raycastTarget = false;
			}
			((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				RowClicked(definition);
			});
			y -= 26f;
		}

		private void RowClicked(IconRegistry.IconDefinition definition)
		{
			try
			{
				if (string.Equals(definition.Id, _selectedIconId, StringComparison.Ordinal))
				{
					_selectedIconId = null;
					if ((Object)(object)_status != (Object)null)
					{
						_status.text = AtlasStrings.Get("palette.pick");
					}
					SelectionCleared?.Invoke();
				}
				else
				{
					_selectedIconId = definition.Id;
					if ((Object)(object)_status != (Object)null)
					{
						_status.text = AtlasStrings.Format("palette.place", definition.DisplayName);
					}
					IconChosen?.Invoke(definition);
				}
				RebuildList();
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			_log.LogError((object)("Enhanced pin palette failed and was disabled for this session (vanilla pin selector remains available): " + SafeLogText.Describe(exception)));
		}
	}
	internal sealed class PinWorkbenchPanel
	{
		private const float PanelWidth = 460f;

		private const float PanelHeight = 560f;

		private const float EdgePadding = 24f;

		private const float LabelColumnWidth = 150f;

		private const float ColumnGap = 12f;

		private const float FieldColumnWidth = 250f;

		private const float LabelCenterX = -131f;

		private const float FieldCenterX = 81f;

		private const float ContentHalfWidth = 206f;

		private const float FieldLeftEdge = -44f;

		private const float ScreenEdgeMargin = 30f;

		private readonly ManualLogSource _log;

		private readonly PinWorkbenchController _controller = new PinWorkbenchController();

		private readonly ModalInputBlock _inputBlock = new ModalInputBlock((Action<bool>)GUIManager.BlockInput);

		private GameObject? _panel;

		private Text? _title;

		private Text? _info;

		private InputField? _name;

		private InputField? _category;

		private InputField? _tags;

		private InputField? _notes;

		private Toggle? _checked;

		private Text? _statusLabel;

		private Text? _scopeLabel;

		private GameObject? _editRows;

		private GameObject? _adoptButton;

		private Image? _iconPreview;

		private Text? _iconButtonLabel;

		private GameObject? _iconDropdown;

		private GameObject? _categoryDropdown;

		private GameObject? _statusDropdown;

		private GameObject? _scopeDropdown;

		private float _iconRowY;

		private float _categoryRowY;

		private float _statusRowY;

		private string _selectedIconId = "vanilla:dot";

		private string? _customIconId;

		private PinOperations? _operations;

		private Action? _onApplied;

		private Func<AtlasPin?>? _adopt;

		private bool _failed;

		public float UiScale = 1f;

		private float _appliedScale = 1f;

		public bool IsVisible
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		public PinWorkbenchPanel(ManualLogSource log)
		{
			_log = log;
		}

		public void OpenForManaged(AtlasPin pin, PinOperations operations, Action onApplied)
		{
			if (!EnsureBuilt())
			{
				return;
			}
			try
			{
				_operations = operations;
				_onApplied = onApplied;
				_adopt = null;
				_controller.Open(pin);
				LoadBufferIntoWidgets();
				SetMode(edit: true, adopt: false);
				_title.text = ((pin.Name.Length == 0) ? AtlasStrings.Get("workbench.title") : ("Pin: " + Truncate(pin.Name, 24)));
				_info.text = _controller.InfoLine;
				Show(visible: true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void OpenAdoptPrompt(string pinName, Func<AtlasPin?> adopt, PinOperations operations, Action onApplied)
		{
			if (!EnsureBuilt())
			{
				return;
			}
			try
			{
				_operations = operations;
				_onApplied = onApplied;
				_adopt = adopt;
				SetMode(edit: false, adopt: true);
				string text = AtlasStrings.Get("workbench.vanillaPin");
				_title.text = ((pinName.Length == 0) ? text : (text + ": " + Truncate(pinName, 20)));
				_info.text = AtlasStrings.Get("workbench.adoptInfo");
				Show(visible: true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void OpenReadOnly(string description)
		{
			if (!EnsureBuilt())
			{
				return;
			}
			try
			{
				_operations = null;
				_adopt = null;
				SetMode(edit: false, adopt: false);
				_title.text = AtlasStrings.Get("workbench.foreignPin");
				_info.text = description + " — " + AtlasStrings.Get("workbench.foreignInfo");
				Show(visible: true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		public void Close()
		{
			_controller.Cancel();
			Show(visible: false);
		}

		public void HandleFrame()
		{
			if (IsVisible)
			{
				if (!Minimap.IsOpen())
				{
					Close();
				}
				else if (Input.GetKeyDown((KeyCode)27) && !CcTextFocus.EscapeShouldOnlyBlur())
				{
					Close();
				}
			}
			else if (_inputBlock.Owned)
			{
				_log.LogError((object)"Workbench invariant violated: the panel is hidden but still owned the GUI input block; releasing it now.");
				_inputBlock.Release();
			}
		}

		private void ApplyClicked()
		{
			try
			{
				if (_operations == null)
				{
					Close();
					return;
				}
				ReadWidgetsIntoBuffer();
				if (_controller.TryApply(_operations, out string message))
				{
					_log.LogInfo((object)$"Workbench: applied changes to {_controller.TargetId}.");
					Show(visible: false);
					_onApplied?.Invoke();
				}
				else
				{
					_info.text = message;
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void DeleteClicked()
		{
			try
			{
				if (_operations != null && _operations.Delete(_controller.TargetId))
				{
					_log.LogInfo((object)$"Workbench: deleted {_controller.TargetId}.");
					Show(visible: false);
					_onApplied?.Invoke();
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void AdoptClicked()
		{
			try
			{
				AtlasPin atlasPin = _adopt?.Invoke();
				if (atlasPin == null)
				{
					_info.text = "Adoption failed; see the log.";
				}
				else
				{
					OpenForManaged(atlasPin, _operations, _onApplied ?? ((Action)delegate
					{
					}));
				}
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void LoadBufferIntoWidgets()
		{
			_name.text = _controller.NameField;
			_category.text = _controller.CategoryField;
			_tags.text = _controller.TagsField;
			_notes.text = _controller.NotesField;
			_checked.isOn = _controller.CheckedField;
			_statusLabel.text = AtlasStrings.Get("workbench.status") + ": " + _controller.StatusField;
			_scopeLabel.text = AtlasStrings.Get("workbench.scope") + ": " + _controller.ScopeField;
			_selectedIconId = ((_controller.IconField.Trim().Length == 0) ? "vanilla:dot" : _controller.IconField.Trim());
			_customIconId = (IconRegistry.TryResolve(_selectedIconId, out IconRegistry.IconDefinition _) ? null : _selectedIconId);
			UpdateIconWidgets();
		}

		private void ReadWidgetsIntoBuffer()
		{
			_controller.NameField = _name.text;
			_controller.IconField = _selectedIconId;
			_controller.CategoryField = _category.text;
			_controller.TagsField = _tags.text;
			_controller.NotesField = _notes.text;
			_controller.CheckedField = _checked.isOn;
		}

		private void SetMode(bool edit, bool adopt)
		{
			CloseDropdowns();
			_editRows.SetActive(edit);
			_adoptButton.SetActive(adopt);
		}

		private void Show(bool visible)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panel == (Object)null)
			{
				return;
			}
			CloseDropdowns();
			if (visible && !Mathf.Approximately(_appliedScale, UiScale))
			{
				_appliedScale = UiScale;
				_panel.transform.localScale = Vector3.one * UiScale;
				((RectTransform)_panel.transform).anchoredPosition = DefaultAnchoredPosition(UiScale);
			}
			_panel.SetActive(visible);
			if (visible)
			{
				_inputBlock.Acquire();
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					object selectedGameObject;
					if (!((Object)(object)_adoptButton != (Object)null) || !_adoptButton.activeSelf)
					{
						InputField? name = _name;
						selectedGameObject = ((name != null) ? ((Component)name).gameObject : null);
					}
					else
					{
						selectedGameObject = _adoptButton;
					}
					current.SetSelectedGameObject((GameObject)selectedGameObject);
				}
			}
			else
			{
				_inputBlock.Release();
			}
		}

		private bool EnsureBuilt()
		{
			if (_failed)
			{
				return false;
			}
			if ((Object)(object)_panel != (Object)null)
			{
				return true;
			}
			if (GUIManager.Instance == null || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				_log.LogWarning((object)"Workbench UI is unavailable (no GUI root yet); use the cc_pins console instead.");
				return false;
			}
			try
			{
				BuildPanel();
				return (Object)(object)_panel != (Object)null;
			}
			catch (Exception exception)
			{
				Fail(exception);
				return false;
			}
		}

		private void BuildPanel()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Expected O, but got Unknown
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Expected O, but got Unknown
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Expected O, but got Unknown
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_0547: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Expected O, but got Unknown
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Expected O, but got Unknown
			GUIManager instance = GUIManager.Instance;
			Font averiaSerifBold = instance.AveriaSerifBold;
			Color val = default(Color);
			((Color)(ref val))..ctor(0.9f, 0.8f, 0.6f, 1f);
			_panel = instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), DefaultAnchoredPosition(1f), 460f, 560f, true);
			_title = instance.CreateText(AtlasStrings.Get("workbench.title"), _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -30f), averiaSerifBold, 20, val, true, Color.black, 412f, 32f, false).GetComponent<Text>();
			_info = instance.CreateText("", _panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -60f), averiaSerifBold, 12, Color.white, false, Color.black, 412f, 40f, false).GetComponent<Text>();
			_editRows = new GameObject("CCEditRows", new Type[1] { typeof(RectTransform) });
			_editRows.transform.SetParent(_panel.transform, false);
			RectTransform val2 = (RectTransform)_editRows.transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			float y = -95f;
			_name = CreateRow(instance, averiaSerifBold, val, AtlasStrings.Get("workbench.name"), ref y);
			BuildIconRow(instance, averiaSerifBold, val, ref y);
			BuildCategoryRow(instance, averiaSerifBold, val, ref y);
			_tags = CreateRow(instance, averiaSerifBold, val, AtlasStrings.Get("workbench.tags"), ref y);
			CreateLabel(instance, averiaSerifBold, val, AtlasStrings.Get("workbench.notes"), new Vector2(-131f, y));
			GameObject val3 = instance.CreateInputField(_editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(81f, y - 22f), (ContentType)0, "notes", 13, 250f, 74f);
			_notes = val3.GetComponent<InputField>();
			_notes.lineType = (LineType)2;
			y = (_statusRowY = y - 92f);
			GameObject val4 = instance.CreateButton("Status", _editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-111f, y), 190f, 30f);
			_statusLabel = val4.GetComponentInChildren<Text>();
			((UnityEvent)val4.GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleStatusDropdown));
			GameObject val5 = instance.CreateButton("Scope", _editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(111f, y), 190f, 30f);
			_scopeLabel = val5.GetComponentInChildren<Text>();
			((UnityEvent)val5.GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleScopeDropdown));
			y -= 38f;
			CreateLabel(instance, averiaSerifBold, val, AtlasStrings.Get("workbench.checked"), new Vector2(-131f, y));
			GameObject val6 = instance.CreateToggle(_editRows.transform, 28f, 28f);
			RectTransform val7 = (RectTransform)val6.transform;
			val7.anchorMin = new Vector2(0.5f, 1f);
			val7.anchorMax = new Vector2(0.5f, 1f);
			val7.anchoredPosition = new Vector2(-30f, y);
			_checked = val6.GetComponentInChildren<Toggle>();
			y -= 40f;
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("workbench.apply"), _editRows.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(-151f, 40f), 110f, 36f).GetComponent<Button>().onClick).AddListener(new UnityAction(ApplyClicked));
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("workbench.delete"), _editRows.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(151f, 40f), 110f, 36f).GetComponent<Button>().onClick).AddListener(new UnityAction(DeleteClicked));
			_adoptButton = instance.CreateButton(AtlasStrings.Get("workbench.adopt"), _panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), 220f, 40f);
			((UnityEvent)_adoptButton.GetComponent<Button>().onClick).AddListener(new UnityAction(AdoptClicked));
			((UnityEvent)instance.CreateButton(AtlasStrings.Get("workbench.close"), _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(0f, 40f), 110f, 36f).GetComponent<Button>().onClick).AddListener(new UnityAction(Close));
			_panel.SetActive(false);
		}

		private void BuildIconRow(GUIManager gui, Font font, Color labelColor, ref float y)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			CreateLabel(gui, font, labelColor, AtlasStrings.Get("workbench.icon"), new Vector2(-131f, y));
			GameObject val = new GameObject("CCIconPreview", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(_editRows.transform, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.anchoredPosition = new Vector2(-31f, y);
			val2.sizeDelta = new Vector2(26f, 26f);
			_iconPreview = val.GetComponent<Image>();
			_iconPreview.preserveAspect = true;
			((Behaviour)_iconPreview).enabled = false;
			float num = 218f;
			GameObject val3 = gui.CreateButton("", _editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-12f + num / 2f, y), num, 28f);
			_iconButtonLabel = val3.GetComponentInChildren<Text>();
			((UnityEvent)val3.GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleIconDropdown));
			_iconRowY = y;
			y -= 36f;
		}

		private void BuildCategoryRow(GUIManager gui, Font font, Color labelColor, ref float y)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			CreateLabel(gui, font, labelColor, AtlasStrings.Get("workbench.category"), new Vector2(-131f, y));
			float num = 214f;
			GameObject val = gui.CreateInputField(_editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-44f + num / 2f, y), (ContentType)0, AtlasStrings.Get("workbench.category"), 14, num, 28f);
			_category = val.GetComponent<InputField>();
			((UnityEvent)gui.CreateButton("...", _editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(-44f + num + 4f + 16f, y), 32f, 28f).GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleCategoryDropdown));
			_categoryRowY = y;
			y -= 36f;
		}

		private void UpdateIconWidgets()
		{
			IconRegistry.IconDefinition definition;
			bool flag = IconRegistry.TryResolve(_selectedIconId, out definition);
			if ((Object)(object)_iconButtonLabel != (Object)null)
			{
				_iconButtonLabel.text = (flag ? definition.DisplayName : AtlasStrings.Format("workbench.customIcon", Truncate(_selectedIconId, 16)));
			}
			if ((Object)(object)_iconPreview != (Object)null)
			{
				Sprite sprite2;
				if (CcIconSprites.TryGet(_selectedIconId, out Sprite sprite))
				{
					_iconPreview.sprite = sprite;
					((Behaviour)_iconPreview).enabled = true;
				}
				else if (MinimapReflection.TryGetPinSprite(IconRegistry.ResolveVanillaType(_selectedIconId), out sprite2))
				{
					_iconPreview.sprite = sprite2;
					((Behaviour)_iconPreview).enabled = true;
				}
				else
				{
					((Behaviour)_iconPreview).enabled = false;
				}
			}
		}

		private void ToggleIconDropdown()
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_iconDropdown != (Object)null && _iconDropdown.activeSelf)
				{
					_iconDropdown.SetActive(false);
					return;
				}
				CloseDropdowns();
				if ((Object)(object)_iconDropdown != (Object)null)
				{
					Object.Destroy((Object)(object)_iconDropdown);
					_iconDropdown = null;
				}
				List<(string, Action)> list = new List<(string, Action)>();
				string customId = _customIconId;
				if (customId != null)
				{
					list.Add((AtlasStrings.Format("workbench.keepCustomIcon", Truncate(customId, 14)), delegate
					{
						_selectedIconId = customId;
						UpdateIconWidgets();
					}));
				}
				foreach (IconRegistry.IconDefinition item in IconRegistry.All)
				{
					string id = item.Id;
					list.Add((item.DisplayName, delegate
					{
						_selectedIconId = id;
						UpdateIconWidgets();
					}));
				}
				_iconDropdown = BuildDropdown(new Vector2(81f, _iconRowY - 16f), 230f, list);
				_iconDropdown.SetActive(true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void ToggleCategoryDropdown()
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_categoryDropdown != (Object)null && _categoryDropdown.activeSelf)
				{
					_categoryDropdown.SetActive(false);
					return;
				}
				CloseDropdowns();
				if ((Object)(object)_categoryDropdown != (Object)null)
				{
					Object.Destroy((Object)(object)_categoryDropdown);
					_categoryDropdown = null;
				}
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				List<(string, Action)> list = new List<(string, Action)>();
				string text = (((Object)(object)_category != (Object)null) ? _category.text.Trim() : "");
				if (text.Length > 0)
				{
					hashSet.Add(text);
				}
				foreach (IconRegistry.IconDefinition item in IconRegistry.All)
				{
					string category = item.DefaultCategory;
					if (category.Length == 0 || !hashSet.Add(category))
					{
						continue;
					}
					list.Add((category, delegate
					{
						if ((Object)(object)_category != (Object)null)
						{
							_category.text = category;
						}
					}));
				}
				_categoryDropdown = BuildDropdown(new Vector2(81f, _categoryRowY - 16f), 230f, list);
				_categoryDropdown.SetActive(true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private GameObject BuildDropdown(Vector2 anchoredPosition, float width, List<(string Label, Action OnPick)> entries)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			GUIManager instance = GUIManager.Instance;
			float num = (float)entries.Count * 28f + 12f;
			GameObject val = new GameObject("CCDropdown", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(_panel.transform, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.anchoredPosition = anchoredPosition + new Vector2(0f, (0f - num) / 2f);
			val2.sizeDelta = new Vector2(width, num);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.13f, 0.1f, 0.07f, 0.98f);
			for (int i = 0; i < entries.Count; i++)
			{
				(string, Action) tuple = entries[i];
				string item = tuple.Item1;
				Action onPick = tuple.Item2;
				GameObject obj = instance.CreateButton(item, val.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -20f - (float)i * 28f), width - 12f, 26f);
				GameObject captured = val;
				((UnityEvent)obj.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					onPick();
					captured.SetActive(false);
				});
			}
			return val;
		}

		private void ToggleStatusDropdown()
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_statusDropdown != (Object)null && _statusDropdown.activeSelf)
				{
					_statusDropdown.SetActive(false);
					return;
				}
				CloseDropdowns();
				if ((Object)(object)_statusDropdown != (Object)null)
				{
					Object.Destroy((Object)(object)_statusDropdown);
					_statusDropdown = null;
				}
				List<(string, Action)> list = new List<(string, Action)>();
				foreach (AtlasPinStatus value in Enum.GetValues(typeof(AtlasPinStatus)))
				{
					AtlasPinStatus captured = value;
					list.Add((value.ToString(), delegate
					{
						_controller.StatusField = captured;
						_statusLabel.text = AtlasStrings.Get("workbench.status") + ": " + captured;
					}));
				}
				_statusDropdown = BuildDropdown(new Vector2(-111f, _statusRowY - 18f), 190f, list);
				_statusDropdown.SetActive(true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void ToggleScopeDropdown()
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_scopeDropdown != (Object)null && _scopeDropdown.activeSelf)
				{
					_scopeDropdown.SetActive(false);
					return;
				}
				CloseDropdowns();
				if ((Object)(object)_scopeDropdown != (Object)null)
				{
					Object.Destroy((Object)(object)_scopeDropdown);
					_scopeDropdown = null;
				}
				List<(string, Action)> list = new List<(string, Action)>();
				foreach (AtlasScope value in Enum.GetValues(typeof(AtlasScope)))
				{
					AtlasScope captured = value;
					list.Add((value.ToString(), delegate
					{
						_controller.ScopeField = captured;
						_scopeLabel.text = AtlasStrings.Get("workbench.scope") + ": " + captured;
					}));
				}
				_scopeDropdown = BuildDropdown(new Vector2(111f, _statusRowY - 18f), 190f, list);
				_scopeDropdown.SetActive(true);
			}
			catch (Exception exception)
			{
				Fail(exception);
			}
		}

		private void CloseDropdowns()
		{
			if ((Object)(object)_iconDropdown != (Object)null)
			{
				_iconDropdown.SetActive(false);
			}
			if ((Object)(object)_categoryDropdown != (Object)null)
			{
				_categoryDropdown.SetActive(false);
			}
			if ((Object)(object)_statusDropdown != (Object)null)
			{
				_statusDropdown.SetActive(false);
			}
			if ((Object)(object)_scopeDropdown != (Object)null)
			{
				_scopeDropdown.SetActive(false);
			}
		}

		private InputField? CreateRow(GUIManager gui, Font font, Color labelColor, string label, ref float y)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			CreateLabel(gui, font, labelColor, label, new Vector2(-131f, y));
			GameObject obj = gui.CreateInputField(_editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(81f, y), (ContentType)0, label, 14, 250f, 28f);
			y -= 36f;
			return obj.GetComponent<InputField>();
		}

		private void CreateLabel(GUIManager gui, Font font, Color color, string text, Vector2 position)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			gui.CreateText(text, _editRows.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), position, font, 13, color, false, Color.black, 150f, 36f, false).GetComponent<Text>().alignment = (TextAnchor)3;
		}

		private static Vector2 DefaultAnchoredPosition(float scale)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(0f - 460f * scale / 2f - 30f, 0f);
		}

		private void Fail(Exception exception)
		{
			_failed = true;
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			_inputBlock.Release();
			_log.LogError((object)("Workbench panel failed and was disabled for this session (cc_pins console remains available): " + SafeLogText.Describe(exception)));
		}

		private static string Truncate(string text, int max)
		{
			if (text.Length > max)
			{
				return text.Substring(0, max) + "…";
			}
			return text;
		}
	}
	internal static class PlayerInputGate
	{
		public static Func<bool>? SuppressAttack;

		public static Func<bool>? SuppressMenu;

		private static Harmony? _harmony;

		private static bool _installed;

		public static void Install(ManualLogSource log)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			if (_installed)
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(Humanoid), "StartAttack", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(Menu), "Update", (Type[])null, (Type[])null);
				if ((object)methodInfo == null || (object)methodInfo2 == null)
				{
					log.LogWarning((object)"Quick Pin input ownership unavailable (vanilla input members not found); armed Quick Pin will not suppress attack/menu input.");
					return;
				}
				_harmony = new Harmony("com.theconcernedcat.valheim.concernedcartographer.playerinput");
				_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PlayerInputGate), "BeforeStartAttack", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(PlayerInputGate), "BeforeMenuUpdate", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_installed = true;
			}
			catch (Exception exception)
			{
				log.LogWarning((object)("Quick Pin input ownership unavailable: " + SafeLogText.Brief(exception)));
				_harmony = null;
			}
		}

		public static void Uninstall()
		{
			try
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
			_harmony = null;
			_installed = false;
		}

		private static bool BeforeStartAttack(Humanoid __instance, ref bool __result)
		{
			try
			{
				Func<bool>? suppressAttack = SuppressAttack;
				if (suppressAttack != null && suppressAttack())
				{
					Player val = (Player)(object)((__instance is Player) ? __instance : null);
					if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
					{
						__result = false;
						return false;
					}
				}
			}
			catch
			{
			}
			return true;
		}

		private static bool BeforeMenuUpdate()
		{
			try
			{
				Func<bool>? suppressMenu = SuppressMenu;
				if (suppressMenu != null && suppressMenu() && !Menu.IsVisible())
				{
					return false;
				}
			}
			catch
			{
			}
			return true;
		}
	}
	internal sealed class RoadOverlayRenderer
	{
		private const string DirtOverlayName = "CC Dirt Paths";

		private const string PavedOverlayName = "CC Paved Roads";

		private readonly CartographerSettings _settings;

		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		private readonly RoadVectorLayer _vectorLayer;

		private bool _userDirtEnabled = true;

		private bool _userPavedEnabled = true;

		private readonly OverlayUserToggleHook _dirtToggleHook = new OverlayUserToggleHook();

		private readonly OverlayUserToggleHook _pavedToggleHook = new OverlayUserToggleHook();

		private MapOverlay? _dirtOverlay;

		private MapOverlay? _pavedOverlay;

		private readonly List<PinData> _alignmentPins = new List<PinData>();

		internal Color32 DirtColor
		{
			get
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				if (!_settings.HighContrast.Value)
				{
					return new Color32((byte)94, (byte)62, (byte)34, byte.MaxValue);
				}
				return new Color32((byte)26, (byte)15, (byte)6, byte.MaxValue);
			}
		}

		internal Color32 PavedColor
		{
			get
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				if (!_settings.HighContrast.Value)
				{
					return new Color32((byte)176, (byte)180, (byte)190, byte.MaxValue);
				}
				return new Color32((byte)245, (byte)245, (byte)250, byte.MaxValue);
			}
		}

		public bool VectorLayerActive => _vectorLayer.IsActive;

		public event Action<RoadKind, bool>? UserToggledOverlay;

		public RoadOverlayRenderer(CartographerSettings settings, ManualLogSource log)
		{
			_settings = settings;
			_log = log;
			_rateLimited = new RateLimitedLog(log, 5f);
			_vectorLayer = new RoadVectorLayer(settings, log);
		}

		public void MarkVectorDataDirty()
		{
			_vectorLayer.MarkDataDirty();
		}

		public void ResetMapSession()
		{
			_dirtOverlay = null;
			_pavedOverlay = null;
			_vectorLayer.ResetSession();
			if (_settings.DebugLogging.Value)
			{
				_log.LogInfo((object)"Road overlay lifecycle: map session reset; cached overlay handles dropped.");
			}
		}

		public void SetRouteVectorVisible(bool visible)
		{
			_vectorLayer.SetRoutesEnabled(visible);
		}

		public void TickVectorLayer(float unscaledDeltaTime, RoadAtlas atlas, RouteStore? routes)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			MaintainToggleHooks();
			_vectorLayer.Tick(unscaledDeltaTime, atlas, routes, _settings.HighContrast.Value, DirtColor, PavedColor);
			ApplyTextureVisibility();
		}

		private void MaintainToggleHooks()
		{
			if (TryGetOverlay(RoadKind.Dirt, out MapOverlay overlay))
			{
				_dirtToggleHook.Maintain((MapOverlayBase)(object)overlay, _userDirtEnabled, delegate(bool value)
				{
					HandleUserToggle(RoadKind.Dirt, value);
				});
			}
			if (TryGetOverlay(RoadKind.Paved, out MapOverlay overlay2))
			{
				_pavedToggleHook.Maintain((MapOverlayBase)(object)overlay2, _userPavedEnabled, delegate(bool value)
				{
					HandleUserToggle(RoadKind.Paved, value);
				});
			}
		}

		private void HandleUserToggle(RoadKind kind, bool enabled)
		{
			SetOverlayEnabled(kind, enabled);
			this.UserToggledOverlay?.Invoke(kind, enabled);
		}

		public void EnsureTextureFallback()
		{
			_vectorLayer.ForceInactive();
			ApplyTextureVisibility();
		}

		private void ApplyTextureVisibility()
		{
			bool isActive = _vectorLayer.IsActive;
			SetTextureOverlayEnabled(RoadKind.Dirt, OverlayVisibilityRule.EffectiveTexture(_userDirtEnabled, isActive));
			SetTextureOverlayEnabled(RoadKind.Paved, OverlayVisibilityRule.EffectiveTexture(_userPavedEnabled, isActive));
			_dirtToggleHook.SyncCheckbox(OverlayVisibilityRule.CheckboxShows(_userDirtEnabled));
			_pavedToggleHook.SyncCheckbox(OverlayVisibilityRule.CheckboxShows(_userPavedEnabled));
		}

		private void SetTextureOverlayEnabled(RoadKind kind, bool enabled)
		{
			if (!TryGetOverlay(kind, out MapOverlay overlay))
			{
				return;
			}
			try
			{
				overlay.Enabled = enabled;
			}
			catch (Exception exception)
			{
				_rateLimited.Warning("overlay-toggle", $"Could not toggle the {kind} overlay: {SafeLogText.Brief(exception)}");
			}
		}

		private bool TryGetOverlay(RoadKind kind, out MapOverlay? overlay)
		{
			overlay = ((kind == RoadKind.Dirt) ? _dirtOverlay : _pavedOverlay);
			if (!OverlayHandleRule.MustReresolve(overlay != null, overlay != null && (Object)(object)overlay.OverlayTex != (Object)null))
			{
				return true;
			}
			try
			{
				overlay = MinimapManager.Instance.GetMapOverlay((kind == RoadKind.Dirt) ? "CC Dirt Paths" : "CC Paved Roads", false);
				if (kind == RoadKind.Dirt)
				{
					_dirtOverlay = overlay;
				}
				else
				{
					_pavedOverlay = overlay;
				}
				if (overlay != null && _settings.DebugLogging.Value)
				{
					bool flag = (Object)(object)overlay.OverlayTex != (Object)null;
					_log.LogInfo((object)($"Road overlay lifecycle: {kind} overlay resolved (texture alive={flag}" + (flag ? $", size={((MapOverlayBase)overlay).TextureSize}px)." : ").")));
				}
				return overlay != null;
			}
			catch (Exception exception)
			{
				_rateLimited.Warning("overlay-get", $"Could not resolve the {kind} overlay: {SafeLogText.Brief(exception)}");
				return false;
			}
		}

		public void RedrawAll(RoadAtlas atlas)
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!TryGetOverlay(RoadKind.Dirt, out MapOverlay overlay) || !TryGetOverlay(RoadKind.Paved, out MapOverlay overlay2))
				{
					return;
				}
				Texture2D overlayTex = overlay.OverlayTex;
				Texture2D overlayTex2 = overlay2.OverlayTex;
				bool flag = (Object)(object)overlayTex != (Object)null && (Object)(object)overlayTex2 != (Object)null;
				if (!flag)
				{
					HandleRedrawTeardown("at resolve");
					return;
				}
				int textureSize = ((MapOverlayBase)overlay).TextureSize;
				Color32[] array = (Color32[])(object)new Color32[textureSize * textureSize];
				Color32[] array2 = (Color32[])(object)new Color32[textureSize * textureSize];
				int num = 0;
				foreach (RoadStroke stroke in atlas.Strokes)
				{
					if (stroke.Points.Count == 0 || stroke.Hidden)
					{
						continue;
					}
					Color32[] pixels = ((stroke.Kind == RoadKind.Dirt) ? array : array2);
					Color32 color = ((stroke.Kind == RoadKind.Dirt) ? DirtColor : PavedColor);
					num++;
					if (stroke.Points.Count == 1)
					{
						DrawIntoBuffer(pixels, textureSize, stroke.Points[0], stroke.Points[0], color);
						continue;
					}
					for (int i = 1; i < stroke.Points.Count; i++)
					{
						DrawIntoBuffer(pixels, textureSize, stroke.Points[i - 1], stroke.Points[i], color);
					}
				}
				if (!OverlayHandleRule.MayWrite(flag, (Object)(object)overlayTex != (Object)null && (Object)(object)overlayTex2 != (Object)null))
				{
					HandleRedrawTeardown("between resolve and write");
					return;
				}
				overlayTex.SetPixels32(array);
				overlayTex2.SetPixels32(array2);
				overlayTex.Apply(false);
				overlayTex2.Apply(false);
				if (_settings.DebugLogging.Value)
				{
					_log.LogInfo((object)$"Road overlay lifecycle: full redraw complete ({num} stroke(s) into {textureSize}px textures).");
				}
			}
			catch (Exception exception)
			{
				_log.LogError((object)("Could not rebuild road map overlays: " + SafeLogText.Describe(exception)));
			}
			_vectorLayer.MarkDataDirty();
		}

		private void HandleRedrawTeardown(string phase)
		{
			_dirtOverlay = null;
			_pavedOverlay = null;
			_rateLimited.Warning("redraw-teardown", "Road overlay lifecycle: overlay texture torn down " + phase + " during a full redraw; handles reset, redraw deferred to the next valid map session.");
		}

		public void DrawCalibrationMarkers()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MapOverlay mapOverlay = MinimapManager.Instance.GetMapOverlay("CC Dirt Paths", false);
				int textureSize = ((MapOverlayBase)mapOverlay).TextureSize;
				StampCross(mapOverlay.OverlayTex, textureSize, new Vector3(0f, 0f, 0f), new Color32(byte.MaxValue, (byte)0, byte.MaxValue, byte.MaxValue), "origin (0,0)");
				StampCross(mapOverlay.OverlayTex, textureSize, new Vector3(128f, 0f, 0f), new Color32(byte.MaxValue, byte.MaxValue, (byte)0, byte.MaxValue), "+128m east");
				StampCross(mapOverlay.OverlayTex, textureSize, new Vector3(0f, 0f, 128f), new Color32((byte)0, byte.MaxValue, byte.MaxValue, byte.MaxValue), "+128m north");
				mapOverlay.OverlayTex.Apply(false);
			}
			catch (Exception exception)
			{
				_log.LogWarning((object)("Could not draw calibration markers: " + SafeLogText.Brief(exception)));
			}
		}

		private void StampCross(Texture2D texture, int size, Vector3 world, Color32 color, string label)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = MinimapManager.Instance.WorldToOverlayCoords(world, size);
			int num = Mathf.RoundToInt(val.x);
			int num2 = Mathf.RoundToInt(val.y);
			StampCrossAt(texture, size, num, num2, color);
			_log.LogInfo((object)$"Calibration marker {label}: overlay pixel ({num}, {num2}) of {size}.");
		}

		private static void StampCrossAt(Texture2D texture, int size, int centerX, int centerY, Color32 color, int armTexels = 4)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			for (int i = -armTexels; i <= armTexels; i++)
			{
				int num = centerX + i;
				if (num >= 0 && num < size && centerY >= 0 && centerY < size)
				{
					texture.SetPixel(num, centerY, Color32.op_Implicit(color));
				}
				int num2 = centerY + i;
				if (centerX >= 0 && centerX < size && num2 >= 0 && num2 < size)
				{
					texture.SetPixel(centerX, num2, Color32.op_Implicit(color));
				}
			}
		}

		public string RunAlignmentProbe(Vector3 playerPosition, RoadAtlas atlas)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ClearAlignmentPins();
				MapOverlay mapOverlay = MinimapManager.Instance.GetMapOverlay("CC Dirt Paths", false);
				int textureSize = ((MapOverlayBase)mapOverlay).TextureSize;
				List<(string, Vector3)> list = new List<(string, Vector3)>
				{
					("player", playerPosition),
					("origin", new Vector3(0f, 0f, 0f)),
					("east", new Vector3(128f, 0f, 0f)),
					("north", new Vector3(0f, 0f, 128f))
				};
				if (TryGetLatestDirtPoint(atlas, out var world))
				{
					list.Add(("road", world));
				}
				int textureSize2;
				float num = ((MinimapReflection.TryGetTextureSize(out textureSize2) && textureSize2 > 0) ? ((float)textureSize / (float)textureSize2) : 1f);
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append(string.Format(CultureInfo.InvariantCulture, "{0,-8}{1,-20}{2,-16}{3,-18}{4}", "Probe", "World X/Z", "Native pixel", "Overlay pixel", "Delta px"));
				float num2 = 0f;
				bool flag = true;
				foreach (var (text, val) in list)
				{
					try
					{
						PinData val2 = Minimap.instance.AddPin(val, (PinType)3, "CC " + text, false, false, 0L, default(PlatformUserID));
						if (val2 != null)
						{
							_alignmentPins.Add(val2);
						}
					}
					catch (Exception exception)
					{
						_log.LogWarning((object)("Alignment probe '" + text + "': could not add the native pin: " + SafeLogText.Brief(exception)));
					}
					Vector2 val3 = MinimapManager.Instance.WorldToOverlayCoords(val, textureSize);
					StampCrossAt(mapOverlay.OverlayTex, textureSize, Mathf.RoundToInt(val3.x), Mathf.RoundToInt(val3.y), new Color32(byte.MaxValue, (byte)0, byte.MaxValue, byte.MaxValue), 1);
					string text2 = "n/a";
					string text3 = "n/a";
					if (MinimapReflection.TryWorldToPixel(val, out var pixelX, out var pixelY))
					{
						text2 = FormattableString.Invariant($"({pixelX}, {pixelY})");
						float num3 = val3.x - (float)pixelX * num;
						float num4 = val3.y - (float)pixelY * num;
						float num5 = Mathf.Sqrt(num3 * num3 + num4 * num4);
						num2 = Mathf.Max(num2, num5);
						text3 = FormattableString.Invariant($"{num5:0.00}");
					}
					else
					{
						flag = false;
					}
					stringBuilder.Append('\n').Append(string.Format(CultureInfo.InvariantCulture, "{0,-8}{1,-20}{2,-16}{3,-18}{4}", text, FormattableString.Invariant($"({val.x:0.#}, {val.z:0.#})"), text2, FormattableString.Invariant($"({val3.x:0.0}, {val3.y:0.0})"), text3));
				}
				mapOverlay.OverlayTex.Apply(false);
				float metersPerPixel;
				string text4 = (MinimapReflection.TryGetPixelSize(out metersPerPixel) ? FormattableString.Invariant($"{metersPerPixel:0.###}") : "n/a");
				string text5 = FormattableString.Invariant(FormattableStringFactory.Create("overlaySize={0} mapTextureSize={1} metersPerTexel={2}", textureSize, (textureSize2 > 0) ? textureSize2.ToString(CultureInfo.InvariantCulture) : "n/a", text4));
				string text6 = ((!flag) ? "ALIGNMENT INDETERMINATE: native pixel projection unavailable (see rows above)" : FormattableString.Invariant(FormattableStringFactory.Create("ALIGNMENT {0}: max residual {1:0.00} texels", (num2 <= 1f) ? "PASS" : "FAIL", num2)));
				string text7 = stringBuilder.ToString() + "\n" + text5 + "\n" + text6;
				_log.LogInfo((object)("cc_roads align: " + text6 + " (" + text5 + "). Probe rows are on the console; positions are never logged."));
				return text7 + "\n'cc_roads align clear' removes the markers.";
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("Alignment probe failed: " + SafeLogText.Describe(ex)));
				return "Alignment probe failed: " + ex.Message;
			}
		}

		public void ClearAlignmentProbe()
		{
			ClearAlignmentPins();
		}

		public bool TryGetOverlayProjection(Vector3 world, out Vector2 overlayCoords, out int overlaySize)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			overlayCoords = default(Vector2);
			overlaySize = 0;
			try
			{
				MapOverlay mapOverlay = MinimapManager.Instance.GetMapOverlay("CC Dirt Paths", false);
				overlaySize = ((MapOverlayBase)mapOverlay).TextureSize;
				overlayCoords = MinimapManager.Instance.WorldToOverlayCoords(world, overlaySize);
				return overlaySize > 0;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetLatestDirtPoint(RoadAtlas atlas, out Vector3 world)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			for (int num = atlas.Strokes.Count - 1; num >= 0; num--)
			{
				RoadStroke roadStroke = atlas.Strokes[num];
				if (roadStroke.Kind == RoadKind.Dirt && !roadStroke.Hidden && roadStroke.Points.Count > 0)
				{
					RoadPoint roadPoint = roadStroke.Points[roadStroke.Points.Count - 1];
					world = new Vector3(roadPoint.X, roadPoint.Y, roadPoint.Z);
					return true;
				}
			}
			world = default(Vector3);
			return false;
		}

		private void ClearAlignmentPins()
		{
			foreach (PinData alignmentPin in _alignmentPins)
			{
				try
				{
					Minimap instance = Minimap.instance;
					if (instance != null)
					{
						instance.RemovePin(alignmentPin);
					}
				}
				catch
				{
				}
			}
			_alignmentPins.Clear();
		}

		public void DrawSegment(RoadSegment segment)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!TryGetOverlay(segment.Kind, out MapOverlay overlay))
				{
					_vectorLayer.MarkDataDirty();
					return;
				}
				Color32 color = ((segment.Kind == RoadKind.Dirt) ? DirtColor : PavedColor);
				int textureSize = ((MapOverlayBase)overlay).TextureSize;
				Vector2 val = MinimapManager.Instance.WorldToOverlayCoords(ToVector3(segment.Start), textureSize);
				Vector2 val2 = MinimapManager.Instance.WorldToOverlayCoords(ToVector3(segment.End), textureSize);
				DrawLine(delegate(int x, int y)
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					overlay.OverlayTex.SetPixel(x, y, Color32.op_Implicit(color));
				}, textureSize, Mathf.RoundToInt(val.x), Mathf.RoundToInt(val.y), Mathf.RoundToInt(val2.x), Mathf.RoundToInt(val2.y), _settings.LineWidthPixels.Value);
				overlay.OverlayTex.Apply(false);
			}
			catch (Exception exception)
			{
				_rateLimited.Warning("draw-segment", "Could not draw an incremental road segment: " + SafeLogText.Brief(exception));
			}
			_vectorLayer.MarkDataDirty();
		}

		public void SetOverlayEnabled(RoadKind kind, bool enabled)
		{
			_vectorLayer.SetKindEnabled(kind, enabled);
			if (kind == RoadKind.Dirt)
			{
				_userDirtEnabled = enabled;
			}
			else
			{
				_userPavedEnabled = enabled;
			}
			ApplyTextureVisibility();
		}

		public void DrawPoint(RoadKind kind, RoadPoint point)
		{
			DrawSegment(new RoadSegment(kind, point, point));
		}

		private static Vector3 ToVector3(RoadPoint point)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(point.X, point.Y, point.Z);
		}

		private void DrawIntoBuffer(Color32[] pixels, int size, RoadPoint worldStart, RoadPoint worldEnd, Color32 color)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = MinimapManager.Instance.WorldToOverlayCoords(ToVector3(worldStart), size);
			Vector2 val2 = MinimapManager.Instance.WorldToOverlayCoords(ToVector3(worldEnd), size);
			DrawLine(delegate(int x, int y)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				pixels[y * size + x] = color;
			}, size, Mathf.RoundToInt(val.x), Mathf.RoundToInt(val.y), Mathf.RoundToInt(val2.x), Mathf.RoundToInt(val2.y), _settings.LineWidthPixels.Value);
		}

		private static void DrawLine(Action<int, int> setPixel, int size, int x0, int y0, int x1, int y1, int lineWidth)
		{
			x0 = Mathf.Clamp(x0, 0, size - 1);
			y0 = Mathf.Clamp(y0, 0, size - 1);
			x1 = Mathf.Clamp(x1, 0, size - 1);
			y1 = Mathf.Clamp(y1, 0, size - 1);
			int num = Math.Abs(x1 - x0);
			int num2 = ((x0 < x1) ? 1 : (-1));
			int num3 = -Math.Abs(y1 - y0);
			int num4 = ((y0 < y1) ? 1 : (-1));
			int num5 = num + num3;
			while (true)
			{
				Stamp(setPixel, size, x0, y0, lineWidth);
				if (x0 != x1 || y0 != y1)
				{
					int num6 = 2 * num5;
					if (num6 >= num3)
					{
						num5 += num3;
						x0 += num2;
					}
					if (num6 <= num)
					{
						num5 += num;
						y0 += num4;
					}
					continue;
				}
				break;
			}
		}

		private static void Stamp(Action<int, int> setPixel, int size, int centerX, int centerY, int lineWidth)
		{
			int num = Math.Max(1, lineWidth) / 2;
			int num2 = Math.Max(1, lineWidth) - 1 - num;
			for (int i = centerY - num; i <= centerY + num2; i++)
			{
				if (i < 0 || i >= size)
				{
					continue;
				}
				for (int j = centerX - num; j <= centerX + num2; j++)
				{
					if (j >= 0 && j < size)
					{
						setPixel(j, i);
					}
				}
			}
		}
	}
	internal sealed class RoadVectorLayer
	{
		private sealed class RoadVectorGraphic : MaskableGraphic
		{
			private readonly List<Vector2> _quadCorners = new List<Vector2>();

			private readonly List<Color32> _quadColors = new List<Color32>();

			private Color32 _inkColor;

			private bool _building;

			public Texture2D? FeatherTexture;

			public override Texture mainTexture
			{
				get
				{
					if (!((Object)(object)FeatherTexture != (Object)null))
					{
						return ((Graphic)this).mainTexture;
					}
					return (Texture)(object)FeatherTexture;
				}
			}

			public void BeginQuads(Color32 inkColor)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				_inkColor = inkColor;
				_quadCorners.Clear();
				_quadColors.Clear();
				_building = true;
			}

			public void AddSegmentQuad(float startX, float startY, float endX, float endY, float halfWidth)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				AddSegmentQuad(startX, startY, endX, endY, halfWidth, _inkColor);
			}

			public void AddSegmentQuad(float startX, float startY, float endX, float endY, float halfWidth, Color32 color)
			{
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				if (_building)
				{
					float num = endX - startX;
					float num2 = endY - startY;
					float num3 = Mathf.Sqrt(num * num + num2 * num2);
					float num4;
					float num5;
					if (num3 <= 1E-06f)
					{
						num4 = 0f;
						num5 = halfWidth;
						num = halfWidth;
						num2 = 0f;
					}
					else
					{
						num4 = (0f - num2) / num3 * halfWidth;
						num5 = num / num3 * halfWidth;
						num = 0f;
						num2 = 0f;
					}
					_quadCorners.Add(new Vector2(startX - num + num4, startY - num2 + num5));
					_quadCorners.Add(new Vector2(endX + num + num4, endY + num2 + num5));
					_quadCorners.Add(new Vector2(endX + num - num4, endY + num2 - num5));
					_quadCorners.Add(new Vector2(startX - num - num4, startY - num2 - num5));
					_quadColors.Add(color);
				}
			}

			public void CommitQuads()
			{
				_building = false;
				((Graphic)this).SetVerticesDirty();
			}

			protected override void OnPopulateMesh(VertexHelper vh)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				vh.Clear();
				UIVertex simpleVert = UIVertex.simpleVert;
				bool flag = (Object)(object)FeatherTexture != (Object)null;
				for (int i = 0; i + 3 < _quadCorners.Count; i += 4)
				{
					int currentVertCount = vh.currentVertCount;
					simpleVert.color = _quadColors[i / 4];
					for (int j = 0; j < 4; j++)
					{
						simpleVert.position = Vector2.op_Implicit(_quadCorners[i + j]);
						if (flag)
						{
							simpleVert.uv0 = Vector4.op_Implicit(new Vector2(0.5f, (j < 2) ? 1f : 0f));
						}
						vh.AddVert(simpleVert);
					}
					vh.AddTriangle(currentVertCount, currentVertCount + 1, currentVertCount + 2);
					vh.AddTriangle(currentVertCount, currentVertCount + 2, currentVertCount + 3);
				}
			}
		}

		private const string ContainerName = "CcRoadVectorLayer";

		private const float TargetScreenWidthPixels = 6f;

		private const float DashOnScreenPixels = 12f;

		private const float DashOffScreenPixels = 8f;

		private const float DotSpacingScreenPixels = 9f;

		private const int MaxQuads = 16000;

		private const int MaxRouteQuads = 20000;

		private const int MaxQuadsPerRoute = 4000;

		private readonly CartographerSettings _settings;

		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		private readonly VectorBakeScheduler _scheduler = new VectorBakeScheduler();

		private RectTransform? _container;

		private RoadVectorGraphic? _dirtGraphic;

		private RoadVectorGraphic? _pavedGraphic;

		private RoadVectorGraphic? _routeGraphic;

		private bool _dirtVisible = true;

		private bool _pavedVisible = true;

		private bool _routesVisible = true;

		private bool _routeBudgetWarned;

		private bool _bakeIncompleteWarned;

		private Color32 _bakedDirtColor;

		private Color32 _bakedPavedColor;

		private bool _disabledForSession;

		private static Texture2D? _featherTexture;

		private int _bakeProjectionFailures;

		private readonly List<(float X, float Y)> _routeBaked = new List<(float, float)>();

		public bool IsActive
		{
			get
			{
				if (!_disabledForSession && _settings.HighPrecisionLargeMapRoads.Value && (Object)(object)_container != (Object)null)
				{
					return ((Component)_container).gameObject.activeInHierarchy;
				}
				return false;
			}
		}

		public RoadVectorLayer(CartographerSettings settings, ManualLogSource log)
		{
			_settings = settings;
			_log = log;
			_rateLimited = new RateLimitedLog(log, 5f);
		}

		public void MarkDataDirty()
		{
			_scheduler.MarkDataDirty();
		}

		public void ResetSession()
		{
			_disabledForSession = false;
			_routeBudgetWarned = false;
			_bakeIncompleteWarned = false;
			_scheduler.Invalidate();
		}

		public void SetKindEnabled(RoadKind kind, bool enabled)
		{
			if (kind == RoadKind.Dirt)
			{
				_dirtVisible = enabled;
			}
			else
			{
				_pavedVisible = enabled;
			}
		}

		public void SetRoutesEnabled(bool enabled)
		{
			_routesVisible = enabled;
		}

		public void Tick(float unscaledDeltaTime, RoadAtlas atlas, RouteStore? routes, bool highContrast, Color32 dirtColor, Color32 pavedColor)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			if (_disabledForSession)
			{
				return;
			}
			try
			{
				if (!_settings.Enabled.Value || !_settings.HighPrecisionLargeMapRoads.Value)
				{
					DestroyContainer();
					return;
				}
				Minimap instance = Minimap.instance;
				if ((Object)(object)instance == (Object)null)
				{
					ReleaseDeadReferences();
					return;
				}
				RawImage mapImageLarge = instance.m_mapImageLarge;
				if ((Object)(object)mapImageLarge == (Object)null)
				{
					return;
				}
				_scheduler.Advance(unscaledDeltaTime);
				if ((Object)(object)instance.m_largeRoot == (Object)null || !instance.m_largeRoot.activeInHierarchy)
				{
					return;
				}
				EnsureCreated(mapImageLarge);
				if ((Object)(object)_container == (Object)null || (Object)(object)_dirtGraphic == (Object)null || (Object)(object)_pavedGraphic == (Object)null)
				{
					return;
				}
				Rect uvRect = mapImageLarge.uvRect;
				Rect rect = ((Graphic)mapImageLarge).rectTransform.rect;
				if (!(((Rect)(ref uvRect)).width <= 0f) && !(((Rect)(ref uvRect)).height <= 0f) && !(((Rect)(ref rect)).width <= 0f) && !(((Rect)(ref rect)).height <= 0f))
				{
					var (num, num2, num3, num4) = RoadVectorMath.ContentTransform(((Rect)(ref uvRect)).xMin, ((Rect)(ref uvRect)).yMin, ((Rect)(ref uvRect)).width, ((Rect)(ref uvRect)).height, ((Rect)(ref rect)).width, ((Rect)(ref rect)).height);
					_container.anchoredPosition = new Vector2(num3, num4);
					((Transform)_container).localScale = new Vector3(num, num2, 1f);
					((Behaviour)_dirtGraphic).enabled = _dirtVisible;
					((Behaviour)_pavedGraphic).enabled = _pavedVisible;
					if ((Object)(object)_routeGraphic != (Object)null)
					{
						((Behaviour)_routeGraphic).enabled = _routesVisible;
					}
					bool stylingChanged = !((Color32)(ref _bakedDirtColor)).Equals(dirtColor) || !((Color32)(ref _bakedPavedColor)).Equals(pavedColor);
					if (_scheduler.ShouldRebake(((Rect)(ref uvRect)).width, stylingChanged))
					{
						Rebake(atlas, routes, highContrast, mapImageLarge, uvRect, rect, dirtColor, pavedColor);
					}
				}
			}
			catch (Exception exception)
			{
				_disabledForSession = true;
				_log.LogError((object)("High-precision road layer disabled for this session: " + SafeLogText.Describe(exception)));
				DestroyContainer();
			}
		}

		private void EnsureCreated(RawImage image)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_container != (Object)null) || !((Object)(object)((Transform)_container).parent == (Object)(object)((Graphic)image).rectTransform))
			{
				DestroyContainer();
				GameObject val = new GameObject("CcRoadVectorLayer", new Type[1] { typeof(RectTransform) });
				_container = (RectTransform)val.transform;
				((Transform)_container).SetParent((Transform)(object)((Graphic)image).rectTransform, false);
				((Transform)_container).SetAsLastSibling();
				_container.anchorMin = Vector2.zero;
				_container.anchorMax = Vector2.zero;
				_container.pivot = Vector2.zero;
				_container.sizeDelta = Vector2.zero;
				_container.anchoredPosition = Vector2.zero;
				Texture2D featherTexture = GetFeatherTexture();
				_dirtGraphic = CreateGraphic("CcRoadVectorDirt", _container, featherTexture);
				_pavedGraphic = CreateGraphic("CcRoadVectorPaved", _container, featherTexture);
				_routeGraphic = CreateGraphic("CcRouteVector", _container, null);
				_scheduler.Invalidate();
			}
		}

		private static Texture2D GetFeatherTexture()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_featherTexture != (Object)null)
			{
				return _featherTexture;
			}
			Texture2D val = new Texture2D(1, 64, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1
			};
			for (int i = 0; i < 64; i++)
			{
				float normalizedOffsetFromCenter = Mathf.Abs(((float)i + 0.5f) / 64f * 2f - 1f);
				float num = ((i == 0 || i == 63) ? 0f : RoadInkSoftening.Alpha(normalizedOffsetFromCenter));
				val.SetPixel(0, i, new Color(1f, 1f, 1f, num));
			}
			val.Apply(false, true);
			_featherTexture = val;
			return val;
		}

		private static RoadVectorGraphic CreateGraphic(string name, RectTransform parent, Texture2D? featherTexture)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)parent, false);
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.zero;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.sizeDelta = new Vector2(2048f, 2048f);
			val2.anchoredPosition = Vector2.zero;
			RoadVectorGraphic roadVectorGraphic = val.AddComponent<RoadVectorGraphic>();
			((Graphic)roadVectorGraphic).raycastTarget = false;
			roadVectorGraphic.FeatherTexture = featherTexture;
			return roadVectorGraphic;
		}

		private void Rebake(RoadAtlas atlas, RouteStore? routes, bool highContrast, RawImage image, Rect uvRect, Rect rect, Color32 dirtColor, Color32 pavedColor)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			_bakeProjectionFailures = 0;
			_bakedDirtColor = dirtColor;
			_bakedPavedColor = pavedColor;
			float num = 1f;
			if (MapScreenMath.TryGetPixelsPerGuiUnit(image, out var pixelsPerGuiUnit) && pixelsPerGuiUnit > 0f)
			{
				num = 1f / pixelsPerGuiUnit;
			}
			float num2 = RoadVectorMath.BakedHalfWidth(6f * num, ((Rect)(ref uvRect)).width, ((Rect)(ref rect)).width);
			if (num2 <= 0f)
			{
				return;
			}
			float halfWidth = num2 * 1.3333334f;
			float bakedUnitsPerScreenPixel = RoadVectorMath.BakedHalfWidth(num, ((Rect)(ref uvRect)).width, ((Rect)(ref rect)).width) * 2f;
			_dirtGraphic.BeginQuads(dirtColor);
			_pavedGraphic.BeginQuads(pavedColor);
			int num3 = 0;
			bool explored;
			bool flag = MinimapReflection.TryIsExplored(Vector3.zero, out explored);
			Vector3 world = default(Vector3);
			foreach (RoadStroke stroke in atlas.Strokes)
			{
				if (stroke.Hidden || stroke.Points.Count == 0)
				{
					continue;
				}
				RoadVectorGraphic roadVectorGraphic = ((stroke.Kind == RoadKind.Dirt) ? _dirtGraphic : _pavedGraphic);
				bool flag2 = false;
				float startX = 0f;
				float startY = 0f;
				bool flag3 = false;
				foreach (RoadPoint point in stroke.Points)
				{
					((Vector3)(ref world))..ctor(point.X, point.Y, point.Z);
					if (!MinimapReflection.TryWorldToMapPoint(world, out var mapX, out var mapY))
					{
						_bakeProjectionFailures++;
						flag2 = false;
						continue;
					}
					(float X, float Y) tuple = RoadVectorMath.Bake(mapX, mapY);
					float item = tuple.X;
					float item2 = tuple.Y;
					bool explored2 = true;
					if (flag)
					{
						MinimapReflection.TryIsExplored(world, out explored2);
					}
					if (flag2 && (explored2 || flag3))
					{
						if (num3 >= 16000)
						{
							DisableOverBudget();
							return;
						}
						roadVectorGraphic.AddSegmentQuad(startX, startY, item, item2, halfWidth);
						num3++;
					}
					else if (!flag2 && stroke.Points.Count == 1 && explored2)
					{
						if (num3 >= 16000)
						{
							DisableOverBudget();
							return;
						}
						roadVectorGraphic.AddSegmentQuad(item, item2, item, item2, halfWidth);
						num3++;
					}
					flag2 = true;
					startX = item;
					startY = item2;
					flag3 = explored2;
				}
			}
			_dirtGraphic.CommitQuads();
			_pavedGraphic.CommitQuads();
			BakeRoutes(routes, highContrast, num2, bakedUnitsPerScreenPixel);
			if (_bakeProjectionFailures > 0)
			{
				_scheduler.OnBakeIncomplete();
				if (!_bakeIncompleteWarned)
				{
					_bakeIncompleteWarned = true;
					_log.LogWarning((object)($"Vector bake could not project {_bakeProjectionFailures} point(s); " + "showing the partial result and retrying (logged once per session)."));
				}
			}
			else
			{
				_scheduler.OnBakeCommitted(((Rect)(ref uvRect)).width);
			}
		}

		private void BakeRoutes(RouteStore? routes, bool highContrast, float halfWidth, float bakedUnitsPerScreenPixel)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_routeGraphic == (Object)null)
			{
				return;
			}
			_routeGraphic.BeginQuads(new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue));
			if (routes == null || bakedUnitsPerScreenPixel <= 0f)
			{
				_routeGraphic.CommitQuads();
				return;
			}
			float num = 12f * bakedUnitsPerScreenPixel;
			float num2 = 8f * bakedUnitsPerScreenPixel;
			float num3 = 9f * bakedUnitsPerScreenPixel;
			int num4 = 0;
			_routeBaked.Clear();
			foreach (AtlasRoute item3 in routes.Living)
			{
				if (item3.Archived || item3.Points.Count == 0 || num4 >= 20000)
				{
					continue;
				}
				_routeBaked.Clear();
				float num5 = 0f;
				foreach (RoadPoint point in item3.Points)
				{
					if (!MinimapReflection.TryWorldToMapPoint(new Vector3(point.X, point.Y, point.Z), out var mapX, out var mapY))
					{
						_bakeProjectionFailures++;
						continue;
					}
					var (num6, num7) = RoadVectorMath.Bake(mapX, mapY);
					if (float.IsNaN(num6) || float.IsInfinity(num6) || float.IsNaN(num7) || float.IsInfinity(num7))
					{
						_bakeProjectionFailures++;
						continue;
					}
					if (_routeBaked.Count > 0)
					{
						(float X, float Y) tuple2 = _routeBaked[_routeBaked.Count - 1];
						float item = tuple2.X;
						float item2 = tuple2.Y;
						num5 += Mathf.Sqrt((num6 - item) * (num6 - item) + (num7 - item2) * (num7 - item2));
					}
					_routeBaked.Add((num6, num7));
				}
				if (_routeBaked.Count == 0)
				{
					continue;
				}
				Color32 color = RouteInk.Resolve(item3, highContrast);
				if (_routeBaked.Count == 1)
				{
					_routeGraphic.AddSegmentQuad(_routeBaked[0].X, _routeBaked[0].Y, _routeBaked[0].X, _routeBaked[0].Y, halfWidth, color);
					num4++;
					continue;
				}
				RouteStyle routeStyle = item3.Style;
				if (routeStyle != RouteStyle.Solid)
				{
					float num8 = ((routeStyle == RouteStyle.Dotted) ? num3 : (num + num2));
					float num9 = ((num8 > 0f) ? (num5 / num8 + (float)_routeBaked.Count) : float.PositiveInfinity);
					if (!(num9 <= 4000f) || !((float)num4 + num9 <= 20000f))
					{
						routeStyle = RouteStyle.Solid;
						if (!_routeBudgetWarned)
						{
							_routeBudgetWarned = true;
							_log.LogInfo((object)"A styled route exceeds the vector stamp budget at this zoom and renders solid instead.");
						}
					}
				}
				int maxStamps = Mathf.Min(4000, 20000 - num4);
				switch (routeStyle)
				{
				case RouteStyle.Dashed:
					num4 += RoutePatternMath.WalkDashes(_routeBaked, num, num2, maxStamps, delegate(float fromX, float fromY, float toX, float toY)
					{
						//IL_0021: Unknown result type (might be due to invalid IL or missing references)
						_routeGraphic.AddSegmentQuad(fromX, fromY, toX, toY, halfWidth, color);
					});
					continue;
				case RouteStyle.Dotted:
					num4 += RoutePatternMath.WalkDots(_routeBaked, num3, maxStamps, delegate(float x, float y)
					{
						//IL_0020: Unknown result type (might be due to invalid IL or missing references)
						_routeGraphic.AddSegmentQuad(x, y, x, y, halfWidth, color);
					});
					continue;
				}
				for (int num10 = 1; num10 < _routeBaked.Count; num10++)
				{
					if (num4 >= 20000)
					{
						break;
					}
					_routeGraphic.AddSegmentQuad(_routeBaked[num10 - 1].X, _routeBaked[num10 - 1].Y, _routeBaked[num10].X, _routeBaked[num10].Y, halfWidth, color);
					num4++;
				}
			}
			_routeGraphic.CommitQuads();
		}

		private void DisableOverBudget()
		{
			_disabledForSession = true;
			_log.LogWarning((object)($"High-precision road layer exceeded its {16000} segment budget and is disabled " + "for this session; the complete texture overlay remains the road view."));
			DestroyContainer();
		}

		public void ForceInactive()
		{
			DestroyContainer();
		}

		private void ReleaseDeadReferences()
		{
			_container = null;
			_dirtGraphic = null;
			_pavedGraphic = null;
			_routeGraphic = null;
		}

		private void DestroyContainer()
		{
			if ((Object)(object)_container != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_container).gameObject);
			}
			ReleaseDeadReferences();
		}
	}
	internal static class RouteInk
	{
		public static Color32 Resolve(AtlasRoute route, bool highContrast)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			int? colorArgb = route.ColorArgb;
			if (colorArgb.HasValue)
			{
				int valueOrDefault = colorArgb.GetValueOrDefault();
				return FromArgb(valueOrDefault);
			}
			return (Color32)(route.Status switch
			{
				RouteStatus.Active => highContrast ? new Color32(byte.MaxValue, (byte)160, (byte)0, byte.MaxValue) : new Color32(byte.MaxValue, (byte)200, (byte)80, byte.MaxValue), 
				RouteStatus.Done => highContrast ? new Color32((byte)200, (byte)200, (byte)200, byte.MaxValue) : new Color32((byte)135, (byte)135, (byte)135, byte.MaxValue), 
				_ => highContrast ? new Color32((byte)0, (byte)220, byte.MaxValue, byte.MaxValue) : new Color32((byte)210, (byte)210, (byte)235, byte.MaxValue), 
			});
		}

		public static Color32 FromArgb(int argb)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return new Color32((byte)((argb >> 16) & 0xFF), (byte)((argb >> 8) & 0xFF), (byte)(argb & 0xFF), (byte)((argb >> 24) & 0xFF));
		}
	}
	internal sealed class RouteOverlayRenderer
	{
		private const string OverlayName = "CC Routes";

		private const float DashOnTexels = 5f;

		private const float DashOffTexels = 4f;

		private const float DotSpacingTexels = 3f;

		private const int MaxPatternStampsPerRoute = 24000;

		private readonly CartographerSettings _settings;

		private readonly RateLimitedLog _rateLimited;

		private readonly OverlayUserToggleHook _toggleHook = new OverlayUserToggleHook();

		private MapOverlay? _overlay;

		private bool _userEnabled = true;

		private bool _lastSuppressed;

		private readonly List<(float X, float Y)> _projected = new List<(float, float)>();

		private Color32[]? _pixelBuffer;

		private int _pixelBufferSize;

		public event Action<bool>? UserToggled;

		public RouteOverlayRenderer(CartographerSettings settings, ManualLogSource log)
		{
			_settings = settings;
			_rateLimited = new RateLimitedLog(log, 5f);
		}

		public void ResetMapSession()
		{
			_overlay = null;
		}

		public void TickVisibility(bool vectorRoutesActive)
		{
			_lastSuppressed = vectorRoutesActive;
			if (TryGetOverlay(out MapOverlay overlay))
			{
				_toggleHook.Maintain((MapOverlayBase)(object)overlay, _userEnabled, HandleUserToggle);
			}
			ApplyVisibility();
		}

		private void HandleUserToggle(bool enabled)
		{
			SetEnabled(enabled);
			this.UserToggled?.Invoke(enabled);
		}

		private void ApplyVisibility()
		{
			bool enabled = OverlayVisibilityRule.EffectiveTexture(_userEnabled, _lastSuppressed);
			if (TryGetOverlay(out MapOverlay overlay))
			{
				try
				{
					overlay.Enabled = enabled;
				}
				catch (Exception exception)
				{
					_rateLimited.Warning("route-toggle", "Could not toggle the route overlay: " + SafeLogText.Brief(exception));
				}
			}
			_toggleHook.SyncCheckbox(OverlayVisibilityRule.CheckboxShows(_userEnabled));
		}

		private bool TryGetOverlay(out MapOverlay? overlay)
		{
			overlay = _overlay;
			if (!OverlayHandleRule.MustReresolve(overlay != null, overlay != null && (Object)(object)overlay.OverlayTex != (Object)null))
			{
				return true;
			}
			try
			{
				overlay = MinimapManager.Instance.GetMapOverlay("CC Routes", false);
				_overlay = overlay;
				return overlay != null;
			}
			catch (Exception exception)
			{
				_rateLimited.Warning("route-overlay-get", "Could not resolve the route overlay: " + SafeLogText.Brief(exception));
				return false;
			}
		}

		public void RedrawAll(RouteStore routes)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!TryGetOverlay(out MapOverlay overlay))
				{
					return;
				}
				Texture2D overlayTex = overlay.OverlayTex;
				if ((Object)(object)overlayTex == (Object)null)
				{
					_overlay = null;
					_rateLimited.Warning("route-redraw-teardown", "Route overlay lifecycle: overlay texture torn down at resolve during a full redraw; handle reset, redraw deferred to the next valid map session.");
					return;
				}
				int textureSize = ((MapOverlayBase)overlay).TextureSize;
				Color32[] array;
				if (_pixelBuffer != null && _pixelBufferSize == textureSize)
				{
					array = _pixelBuffer;
					Array.Clear(array, 0, array.Length);
				}
				else
				{
					array = (_pixelBuffer = (Color32[]?)(object)new Color32[textureSize * textureSize]);
					_pixelBufferSize = textureSize;
				}
				foreach (AtlasRoute item in routes.Living)
				{
					if (item.Archived || item.Points.Count == 0)
					{
						continue;
					}
					Color32 color = RouteInk.Resolve(item, _settings.HighContrast.Value);
					if (item.Points.Count == 1)
					{
						DrawSegmentIntoBuffer(array, textureSize, item.Points[0], item.Points[0], color);
						continue;
					}
					switch (item.Style)
					{
					case RouteStyle.Dashed:
						DrawDashedPolyline(array, textureSize, item.Points, color);
						continue;
					case RouteStyle.Dotted:
						DrawDottedPolyline(array, textureSize, item.Points, color);
						continue;
					}
					for (int i = 1; i < item.Points.Count; i++)
					{
						DrawSegmentIntoBuffer(array, textureSize, item.Points[i - 1], item.Points[i], color);
					}
				}
				if (!OverlayHandleRule.MayWrite(textureAliveAtResolve: true, (Object)(object)overlayTex != (Object)null))
				{
					_overlay = null;
					_rateLimited.Warning("route-redraw-teardown", "Route overlay lifecycle: overlay texture torn down between resolve and write during a full redraw; handle reset, redraw deferred to the next valid map session.");
				}
				else
				{
					overlayTex.SetPixels32(array);
					overlayTex.Apply(false);
				}
			}
			catch (Exception exception)
			{
				_rateLimited.Warning("route-redraw", "Could not redraw routes: " + SafeLogText.Brief(exception));
			}
		}

		public void SetEnabled(bool enabled)
		{
			_userEnabled = enabled;
			ApplyVisibility();
		}

		private void ProjectPolyline(IReadOnlyList<RoadPoint> points, int size)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			_projected.Clear();
			foreach (RoadPoint point in points)
			{
				Vector2 val = Project(point, size);
				_projected.Add((val.x, val.y));
			}
		}

		private void DrawDashedPolyline(Color32[] pixels, int size, IReadOnlyList<RoadPoint> points, Color32 color)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			ProjectPolyline(points, size);
			RoutePatternMath.WalkDashes(_projected, 5f, 4f, 24000, delegate(float fromX, float fromY, float toX, float toY)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				DrawLineIntoBuffer(pixels, size, new Vector2(fromX, fromY), new Vector2(toX, toY), color);
			});
		}

		private void DrawDottedPolyline(Color32[] pixels, int size, IReadOnlyList<RoadPoint> points, Color32 color)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			ProjectPolyline(points, size);
			RoutePatternMath.WalkDots(_projected, 3f, 24000, delegate(float x, float y)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				DrawLineIntoBuffer(pixels, size, new Vector2(x, y), new Vector2(x, y), color);
			});
		}

		private static Vector2 Project(RoadPoint point, int size)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return MinimapManager.Instance.WorldToOverlayCoords(new Vector3(point.X, point.Y, point.Z), size);
		}

		private void DrawSegmentIntoBuffer(Color32[] pixels, int size, RoadPoint start, RoadPoint end, Color32 color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			DrawLineIntoBuffer(pixels, size, Project(start, size), Project(end, size), color);
		}

		private void DrawLineIntoBuffer(Color32[] pixels, int size, Vector2 a, Vector2 b, Color32 color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Clamp(Mathf.RoundToInt(a.x), 0, size - 1);
			int num2 = Mathf.Clamp(Mathf.RoundToInt(a.y), 0, size - 1);
			int num3 = Mathf.Clamp(Mathf.RoundToInt(b.x), 0, size - 1);
			int num4 = Mathf.Clamp(Mathf.RoundToInt(b.y), 0, size - 1);
			int num5 = Math.Abs(num3 - num);
			int num6 = ((num < num3) ? 1 : (-1));
			int num7 = -Math.Abs(num4 - num2);
			int num8 = ((num2 < num4) ? 1 : (-1));
			int num9 = num5 + num7;
			int num10 = Math.Max(1, _settings.LineWidthPixels.Value);
			int num11 = num10 / 2;
			int num12 = num10 - 1 - num11;
			while (true)
			{
				for (int i = num2 - num11; i <= num2 + num12; i++)
				{
					if (i < 0 || i >= size)
					{
						continue;
					}
					for (int j = num - num11; j <= num + num12; j++)
					{
						if (j >= 0 && j < size)
						{
							pixels[i * size + j] = color;
						}
					}
				}
				if (num != num3 || num2 != num4)
				{
					int num13 = 2 * num9;
					if (num13 >= num7)
					{
						num9 += num7;
						num += num6;
					}
					if (num13 <= num5)
					{
						num9 += num5;
						num2 += num8;
					}
					continue;
				}
				break;
			}
		}
	}
	internal sealed class RoutesPanel : CcSidePanel
	{
		private const int RouteSlots = 6;

		private static readonly int[] Swatches = new int[6] { -1519528, -3123136, -10966808, -9910168, -3639072, -986896 };

		private readonly Func<RouteCommandHandler?> _handler;

		private InputField? _name;

		private Toggle? _snap;

		private Text? _modeStatus;

		private Text? _selectionStatus;

		private Text? _output;

		private readonly Button[] _routeButtons = (Button[])(object)new Button[6];

		private readonly Text[] _routeLabels = (Text[])(object)new Text[6];

		private readonly AtlasId[] _routeIds = new AtlasId[6];

		private AtlasId _selected;

		private bool _hasSelection;

		private bool _mergeArmed;

		private long _renderedStamp = -1L;

		private bool _clearAllArmed;

		public bool ModeActive
		{
			get
			{
				RouteCommandHandler routeCommandHandler = _handler();
				if (routeCommandHandler != null && routeCommandHandler.UiModeOwned)
				{
					return routeCommandHandler.Mode != RouteCommandHandler.MapMode.None;
				}
				return false;
			}
		}

		public RoutesPanel(ManualLogSource log, Func<RouteCommandHandler?> handler)
			: base(log, "routes.title", 384f, 672f)
		{
			_handler = handler;
		}

		public override void HandleFrame()
		{
			if (base.IsVisible && ModeActive && Input.GetKeyDown((KeyCode)27) && !CcTextFocus.EscapeShouldOnlyBlur())
			{
				_handler()?.UiStop();
				RefreshMode();
				return;
			}
			if (!base.IsVisible && ModeActive && !Minimap.IsOpen())
			{
				_handler()?.UiStop();
			}
			if (base.IsVisible)
			{
				RouteCommandHandler routeCommandHandler = _handler();
				if (routeCommandHandler != null && routeCommandHandler.ChangeStamp != _renderedStamp)
				{
					_renderedStamp = routeCommandHandler.ChangeStamp;
					RefreshList();
					RefreshMode();
				}
			}
			base.HandleFrame();
		}

		protected override void OnHidden()
		{
			if (ModeActive)
			{
				_handler()?.UiStop();
				RefreshMode();
			}
			base.OnHidden();
		}

		protected override void BuildContent(GUIManager gui, Font font, Color headerColor, ref float y)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Expected O, but got Unknown
			//IL_0607: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			AddBody(gui, font, AtlasStrings.Get("routes.explainer"), 11, new Color(0.85f, 0.82f, 0.7f, 1f), ref y, 28f).alignment = (TextAnchor)1;
			y -= 12f;
			GameObject val = gui.CreateInputField(base.Panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), (ContentType)0, AtlasStrings.Get("routes.nameHint"), 13, base.Width - 44f, 28f);
			_name = val.GetComponent<InputField>();
			y -= 36f;
			float num = (base.Width - 44f) / 3f;
			float num2 = (0f - (base.Width - 44f)) / 2f;
			AddButton(gui, AtlasStrings.Get("routes.freeDraw"), num2 + num * 0.5f, y, num - 4f, 28f, delegate
			{
				StartMode(RouteKind.Freehand);
			});
			AddButton(gui, AtlasStrings.Get("routes.waypoints"), num2 + num * 1.5f, y, num - 4f, 28f, delegate
			{
				StartMode(RouteKind.Waypoint);
			});
			AddButton(gui, AtlasStrings.Get("routes.erase"), num2 + num * 2.5f, y, num - 4f, 28f, delegate
			{
				_handler()?.UiStartErase();
				RefreshMode();
			});
			y -= 34f;
			float num3 = (base.Width - 44f) / 3f;
			AddButton(gui, AtlasStrings.Get("routes.finish"), num2 + num3 * 0.5f, y, num3 - 4f, 28f, delegate
			{
				_handler()?.UiStop();
				RefreshMode();
				RefreshList();
			});
			AddButton(gui, "Undo", num2 + num3 * 1.5f, y, num3 - 4f, 28f, delegate
			{
				RouteCommandHandler routeCommandHandler = _handler();
				if (routeCommandHandler != null)
				{
					routeCommandHandler.UiUndo(out string summary);
					Report(summary);
					RefreshList();
				}
			});
			AddButton(gui, "Redo", num2 + num3 * 2.5f, y, num3 - 4f, 28f, delegate
			{
				RouteCommandHandler routeCommandHandler = _handler();
				if (routeCommandHandler != null)
				{
					routeCommandHandler.UiRedo(out string summary);
					Report(summary);
					RefreshList();
				}
			});
			y -= 34f;
			_modeStatus = AddBody(gui, font, "", 12, new Color(0.85f, 1f, 0.85f, 1f), ref y, 30f);
			_selectionStatus = AddBody(gui, font, "", 12, new Color(1f, 0.95f, 0.75f, 1f), ref y, 30f);
			y -= 10f;
			for (int num4 = 0; num4 < 6; num4++)
			{
				int captured = num4;
				GameObject val2 = gui.CreateButton("", base.Panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), base.Width - 44f, 24f);
				_routeButtons[num4] = val2.GetComponent<Button>();
				_routeLabels[num4] = val2.GetComponentInChildren<Text>();
				((UnityEvent)_routeButtons[num4].onClick).AddListener((UnityAction)delegate
				{
					RowClicked(captured);
				});
				val2.SetActive(false);
				y -= 27f;
			}
			y -= 6f;
			float num5 = (base.Width - 44f) / 5f;
			string[] array = new string[5] { "Rename", "Style", "Status", "Lock", "Archive" };
			string[] array2 = new string[5] { "Delete", "Restore", "Split", "Merge", "Measure" };
			for (int num6 = 0; num6 < 5; num6++)
			{
				string op1 = array[num6];
				string op2 = array2[num6];
				AddButton(gui, op1, num2 + num5 * ((float)num6 + 0.5f), y, num5 - 4f, 26f, delegate
				{
					Operate(op1);
				});
				AddButton(gui, op2, num2 + num5 * ((float)num6 + 0.5f), y - 30f, num5 - 4f, 26f, delegate
				{
					Operate(op2);
				});
			}
			y -= 64f;
			float num7 = (base.Width - 44f) / (float)(Swatches.Length + 1);
			for (int num8 = 0; num8 < Swatches.Length; num8++)
			{
				int argb = Swatches[num8];
				Image component = ((Component)AddButton(gui, "", num2 + num7 * ((float)num8 + 0.5f), y, num7 - 6f, 22f, delegate
				{
					if (_hasSelection)
					{
						RouteCommandHandler routeCommandHandler = _handler();
						if (routeCommandHandler != null)
						{
							Report(routeCommandHandler.UiSetColor(_selected, argb));
						}
					}
				})).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = Color32.op_Implicit(new Color32((byte)((argb >> 16) & 0xFF), (byte)((argb >> 8) & 0xFF), (byte)(argb & 0xFF), byte.MaxValue));
				}
			}
			AddButton(gui, "✕", num2 + num7 * ((float)Swatches.Length + 0.5f), y, num7 - 6f, 22f, delegate
			{
				if (_hasSelection)
				{
					RouteCommandHandler routeCommandHandler = _handler();
					if (routeCommandHandler != null)
					{
						Report(routeCommandHandler.UiSetColor(_selected, null));
					}
				}
			});
			y -= 30f;
			_output = AddBody(gui, font, "", 12, Color.white, ref y, 36f);
			y -= 10f;
			_snap = AddToggle(gui, font, Color.white, AtlasStrings.Get("routes.snap"), num2 + 12f, y, delegate(bool value)
			{
				_handler()?.UiSetSnap(value);
			}, 110f);
			AddButton(gui, "Clear all routes", num2 + 262f, y, 150f, 26f, delegate
			{
				RouteCommandHandler routeCommandHandler = _handler();
				if (routeCommandHandler != null)
				{
					if (!_clearAllArmed)
					{
						_clearAllArmed = true;
						Report($"Click again to delete ALL {routeCommandHandler.LivingRouteCount()} route(s). Restore/Undo can bring them back.");
					}
					else
					{
						_clearAllArmed = false;
						Report(routeCommandHandler.UiClearAll());
						_hasSelection = false;
						RefreshList();
					}
				}
			});
			y -= 30f;
		}

		protected override void OnShown()
		{
			if ((Object)(object)_snap != (Object)null)
			{
				RouteCommandHandler routeCommandHandler = _handler();
				if (routeCommandHandler != null)
				{
					SetToggleSilently(_snap, routeCommandHandler.SnapEnabled);
				}
			}
			_mergeArmed = false;
			_clearAllArmed = false;
			_renderedStamp = _handler()?.ChangeStamp ?? (-1);
			RefreshList();
			RefreshMode();
		}

		private void StartMode(RouteKind kind)
		{
			RouteCommandHandler routeCommandHandler = _handler();
			if (routeCommandHandler != null)
			{
				string text = routeCommandHandler.UiStart(kind, ((Object)(object)_name != (Object)null) ? _name.text : "");
				Report(AtlasStrings.Format((kind == RouteKind.Freehand) ? "routes.modeDraw" : "routes.modeWaypoint", text));
				RefreshMode();
				RefreshList();
			}
		}

		private void RowClicked(int index)
		{
			RouteCommandHandler routeCommandHandler = _handler();
			if (routeCommandHandler != null)
			{
				AtlasId atlasId = _routeIds[index];
				if (_mergeArmed && _hasSelection && !atlasId.Equals(_selected))
				{
					_mergeArmed = false;
					Report(routeCommandHandler.UiMerge(_selected, atlasId));
					RefreshList();
				}
				else
				{
					_selected = atlasId;
					_hasSelection = true;
					_mergeArmed = false;
					RefreshList();
				}
			}
		}

		private void Operate(string op)
		{
			RouteCommandHandler routeCommandHandler = _handler();
			if (routeCommandHandler == null)
			{
				return;
			}
			if (op == "Restore")
			{
				Report(routeCommandHandler.UiRestoreLatest());
				RefreshList();
				return;
			}
			if (!_hasSelection)
			{
				Report("Select a route in the list first.");
				return;
			}
			switch (op)
			{
			case "Rename":
				Report(routeCommandHandler.UiRename(_selected, ((Object)(object)_name != (Object)null) ? _name.text : ""));
				break;
			case "Style":
				Report(routeCommandHandler.UiCycleStyle(_selected));
				break;
			case "Status":
				Report(routeCommandHandler.UiCycleStatus(_selected));
				break;
			case "Lock":
				Report(routeCommandHandler.UiToggleLock(_selected));
				break;
			case "Archive":
				Report(routeCommandHandler.UiToggleArchive(_selected));
				break;
			case "Delete":
				Report(routeCommandHandler.UiDelete(_selected));
				_hasSelection = false;
				break;
			case "Split":
				Report(routeCommandHandler.UiSplit(_selected));
				break;
			case "Merge":
				_mergeArmed = true;
				if (_handler().UiListRoutes(6).Count < 2)
				{
					_mergeArmed = false;
					Report("Need a second route to merge.");
				}
				else
				{
					Report(AtlasStrings.Format("routes.mergePick", RouteName(_selected)));
				}
				return;
			case "Measure":
				Report(routeCommandHandler.UiMeasure(_selected));
				break;
			}
			RefreshList();
		}

		private string RouteName(AtlasId id)
		{
			foreach (var (atlasId, text) in _handler()?.UiListRoutes(6) ?? new List<(AtlasId, string)>())
			{
				if (atlasId.Equals(id))
				{
					int num = text.IndexOf(" [", StringComparison.Ordinal);
					return (num > 0) ? text.Substring(0, num) : text;
				}
			}
			return "route";
		}

		private void RefreshList()
		{
			List<(AtlasId, string)> list = _handler()?.UiListRoutes(6) ?? new List<(AtlasId, string)>();
			bool flag = false;
			for (int i = 0; i < 6; i++)
			{
				bool flag2 = i < list.Count;
				((Component)_routeButtons[i]).gameObject.SetActive(flag2);
				if (flag2)
				{
					_routeIds[i] = list[i].Item1;
					bool flag3 = _hasSelection && list[i].Item1.Equals(_selected);
					flag = flag || flag3;
					_routeLabels[i].text = (flag3 ? "» " : "") + Truncate(list[i].Item2, 44);
				}
			}
			if (_hasSelection && !flag)
			{
				_hasSelection = false;
			}
			if ((Object)(object)_selectionStatus != (Object)null)
			{
				int num = _handler()?.LivingRouteCount() ?? list.Count;
				string text = ((num > list.Count) ? $" ({num - list.Count} more not shown)" : "");
				_selectionStatus.text = (_hasSelection ? ("Selected: " + RouteName(_selected)) : "Click a route below to select it") + text;
			}
		}

		private void RefreshMode()
		{
			if (!((Object)(object)_modeStatus == (Object)null))
			{
				RouteCommandHandler routeCommandHandler = _handler();
				if (routeCommandHandler != null)
				{
					Text modeStatus = _modeStatus;
					modeStatus.text = routeCommandHandler.Mode switch
					{
						RouteCommandHandler.MapMode.Draw => AtlasStrings.Format("routes.modeDraw", routeCommandHandler.ActiveRouteDisplayName), 
						RouteCommandHandler.MapMode.Waypoint => AtlasStrings.Format("routes.modeWaypoint", routeCommandHandler.ActiveRouteDisplayName), 
						RouteCommandHandler.MapMode.Erase => AtlasStrings.Get("routes.modeErase"), 
						_ => "", 
					};
				}
			}
		}

		private void Report(string message)
		{
			if ((Object)(object)_output != (Object)null)
			{
				_output.text = message;
			}
			RefreshMode();
		}

		private static string Truncate(string text, int max)
		{
			if (text.Length > max)
			{
				return text.Substring(0, max) + "…";
			}
			return text;
		}
	}
	internal sealed class SettingsPanel : CcSidePanel
	{
		private readonly Func<string[], string> _executeAtlas;

		private readonly Func<string[], string> _executeRoads;

		private readonly Action _openPrivacy;

		private Text? _output;

		private bool _restoreArmed;

		public SettingsPanel(ManualLogSource log, Func<string[], string> executeAtlas, Func<string[], string> executeRoads, Action openPrivacy)
			: base(log, "settings.title", 384f, 620f)
		{
			_executeAtlas = executeAtlas;
			_executeRoads = executeRoads;
			_openPrivacy = openPrivacy;
		}

		protected override void BuildContent(GUIManager gui, Font font, Color headerColor, ref float y)
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			float num = (0f - (base.Width - 44f)) / 2f;
			float num2 = (base.Width - 44f) / 2f;
			AddButton(gui, "Privacy & crash reports…", 0f, y, base.Width - 44f, 30f, _openPrivacy);
			y -= 38f;
			AddButton(gui, "Back up atlas", num + num2 * 0.5f, y, num2 - 4f, 28f, delegate
			{
				_restoreArmed = false;
				Report(_executeAtlas(new string[1] { "backup" }));
			});
			AddButton(gui, "Restore latest backup", num + num2 * 1.5f, y, num2 - 4f, 28f, delegate
			{
				if (!_restoreArmed)
				{
					_restoreArmed = true;
					Report("Restoring replaces the CURRENT atlas with the newest backup (a safety backup is taken first). Click again to confirm.\n" + _executeAtlas(new string[1] { "backups" }));
				}
				else
				{
					_restoreArmed = false;
					Report(_executeAtlas(new string[2] { "restore", "1" }));
				}
			});
			y -= 34f;
			AddButton(gui, "Write sanitized support bundle", 0f, y, base.Width - 44f, 28f, delegate
			{
				_restoreArmed = false;
				Report(_executeAtlas(new string[1] { "support" }));
			});
			y -= 36f;
			GameObject val = new GameObject("CCSettingsStatus", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(base.Panel.transform, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.anchoredPosition = new Vector2(0f, y - 75f);
			val2.sizeDelta = new Vector2(base.Width - 40f, 150f);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0f, 0f, 0f, 0.45f);
			((Graphic)component).raycastTarget = false;
			_output = gui.CreateText("", val.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, 0f), font, 11, Color.white, false, Color.black, base.Width - 56f, 138f, false).GetComponent<Text>();
			_output.alignment = (TextAnchor)0;
			_output.verticalOverflow = (VerticalWrapMode)0;
			_output.horizontalOverflow = (HorizontalWrapMode)0;
			y -= 160f;
			AddBody(gui, font, "Road repair (Advanced) — acts on the recorded road nearest your character:", 12, headerColor, ref y, 30f);
			y -= 10f;
			string[] array = new string[4] { "Status", "Kind", "Hide", "Unhide" };
			string[] array2 = new string[4] { "Delete", "Split", "Join", "Rebuild" };
			float num3 = (base.Width - 44f) / 4f;
			for (int num4 = 0; num4 < 4; num4++)
			{
				string op1 = array[num4].ToLowerInvariant();
				string op2 = array2[num4].ToLowerInvariant();
				AddButton(gui, array[num4], num + num3 * ((float)num4 + 0.5f), y, num3 - 4f, 26f, delegate
				{
					Report(_executeRoads(new string[1] { op1 }));
				});
				AddButton(gui, array2[num4], num + num3 * ((float)num4 + 0.5f), y - 30f, num3 - 4f, 26f, delegate
				{
					Report(_executeRoads(new string[1] { op2 }));
				});
			}
			y -= 60f;
			AddButton(gui, "Undo road edit", 0f, y, 160f, 26f, delegate
			{
				Report(_executeRoads(new string[1] { "undo" }));
			});
			y -= 32f;
			AddBody(gui, font, AtlasStrings.Get("settings.emailLine"), 11, new Color(1f, 1f, 1f, 0.7f), ref y, 22f);
		}

		protected override void OnShown()
		{
			_restoreArmed = false;
			Report("Action results appear here.");
		}

		private void Report(string message)
		{
			if ((Object)(object)_output != (Object)null)
			{
				_output.text = message;
			}
		}
	}
	internal sealed class SharePanel : CcSidePanel
	{
		private const int InboxSlots = 3;

		private readonly Func<string[], string> _execute;

		private readonly Func<List<string>> _inboxAuthors;

		private Text? _status;

		private Text? _output;

		private readonly GameObject[] _rows = (GameObject[])(object)new GameObject[3];

		private readonly Text[] _rowLabels = (Text[])(object)new Text[3];

		private readonly string[] _rowAuthors = new string[3];

		private string _selectedAuthor = "";

		public SharePanel(ManualLogSource log, Func<string[], string> execute, Func<List<string>> inboxAuthors)
			: base(log, "share.title", 384f, 584f)
		{
			_execute = execute;
			_inboxAuthors = inboxAuthors;
		}

		protected override void BuildContent(GUIManager gui, Font font, Color headerColor, ref float y)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			float num = base.Width - 44f;
			float x = (0f - num) / 4f;
			float x2 = num / 4f;
			float width = num / 2f - 8f;
			AddBody(gui, font, AtlasStrings.Get("share.instructions"), 11, new Color(0.85f, 0.82f, 0.7f, 1f), ref y, 30f).alignment = (TextAnchor)1;
			_status = AddBody(gui, font, "", 12, Color.white, ref y, 76f);
			y -= 10f;
			AddButton(gui, AtlasStrings.Get("share.now"), x, y, width, 28f, delegate
			{
				Report(_execute(new string[1] { "share" }));
				RefreshStatus();
			});
			AddButton(gui, "Clear inbox", x2, y, width, 28f, delegate
			{
				Report(_execute(new string[1] { "clear" }));
				_selectedAuthor = "";
				RefreshStatus();
			});
			y -= 36f;
			for (int num2 = 0; num2 < 3; num2++)
			{
				int captured = num2;
				GameObject val = gui.CreateButton("", base.Panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), num, 24f);
				_rows[num2] = val;
				_rowLabels[num2] = val.GetComponentInChildren<Text>();
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					_selectedAuthor = _rowAuthors[captured];
					Report(_execute(new string[2] { "preview", _selectedAuthor }));
					RefreshStatus();
				});
				val.SetActive(false);
				y -= 28f;
			}
			y -= 8f;
			AddButton(gui, "Apply (keep mine)", x, y, width, 28f, delegate
			{
				Apply("mine");
			});
			AddButton(gui, "Apply (take theirs)", x2, y, width, 28f, delegate
			{
				Apply("theirs");
			});
			y -= 36f;
			_output = AddBody(gui, font, "", 11, Color.white, ref y, 150f);
		}

		protected override void OnShown()
		{
			_selectedAuthor = "";
			Report("Select an inbox entry to preview it. Nothing is ever applied automatically.");
			RefreshStatus();
		}

		private void Apply(string side)
		{
			if (_selectedAuthor.Length == 0)
			{
				Report("Preview an inbox entry first — Apply always follows a preview.");
				return;
			}
			Report(_execute(new string[3] { "apply", _selectedAuthor, side }));
			_selectedAuthor = "";
			RefreshStatus();
		}

		private void RefreshStatus()
		{
			if ((Object)(object)_status != (Object)null)
			{
				_status.text = _execute(new string[1] { "status" });
			}
			List<string> list = _inboxAuthors();
			for (int i = 0; i < 3; i++)
			{
				bool flag = i < list.Count;
				_rows[i].SetActive(flag);
				if (flag)
				{
					_rowAuthors[i] = list[i];
					bool flag2 = list[i] == _selectedAuthor;
					_rowLabels[i].text = (flag2 ? "» " : "") + "Inbox: " + list[i];
				}
			}
		}

		private void Report(string message)
		{
			if ((Object)(object)_output != (Object)null)
			{
				_output.text = message;
			}
		}
	}
	internal sealed class SurveyPanel : CcSidePanel
	{
		private enum View
		{
			Pending,
			Rejected,
			Rules
		}

		private const int Slots = 5;

		private static readonly (string IconId, string Category)[] AddChoices = new(string, string)[6]
		{
			("cc:resource", "Resources"),
			("cc:mine", "Resources"),
			("cc:dungeon", "Dungeons"),
			("cc:objective", "Points of interest"),
			("cc:danger", "Danger"),
			("cc:farm", "Base")
		};

		private readonly CartographerSettings _settings;

		private readonly Func<string[], string> _execute;

		private readonly Func<IReadOnlyList<SurveyEngine.Observation>> _observations;

		private readonly Func<SurveyEngine> _engine;

		private readonly Func<SurveyScanner?> _scanner;

		private Toggle? _enabled;

		private Text? _note;

		private Text? _status;

		private Text? _output;

		private readonly GameObject[] _rows = (GameObject[])(object)new GameObject[5];

		private readonly Text[] _rowLabels = (Text[])(object)new Text[5];

		private readonly Text[] _rowButtonALabels = (Text[])(object)new Text[5];

		private readonly Text[] _rowButtonBLabels = (Text[])(object)new Text[5];

		private readonly Guid[] _rowObservationIds = new Guid[5];

		private readonly string[] _rowRejectedKeys = new string[5];

		private readonly Button[] _viewButtons = (Button[])(object)new Button[3];

		private GameObject? _scanNowButton;

		private GameObject? _acceptAllButton;

		private GameObject? _rejectAllButton;

		private GameObject? _restoreAllButton;

		private GameObject? _addRuleField;

		private GameObject? _addRuleButton;

		private GameObject? _addIconButton;

		private Text? _addIconLabel;

		private GameObject? _reloadButton;

		private GameObject? _pageBack;

		private GameObject? _pageForward;

		private InputField? _addRuleInput;

		private View _view;

		private int _page;

		private int _addChoice;

		private string _pendingConfirm = "";

		private float _refreshElapsed;

		public SurveyPanel(ManualLogSource log, CartographerSettings settings, Func<string[], string> execute, Func<IReadOnlyList<SurveyEngine.Observation>> observations, Func<SurveyEngine> engine, Func<SurveyScanner?> scanner)
			: base(log, "survey.title", 384f, 648f)
		{
			_settings = settings;
			_execute = execute;
			_observations = observations;
			_engine = engine;
			_scanner = scanner;
		}

		protected override void BuildContent(GUIManager gui, Font font, Color headerColor, ref float y)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Expected O, but got Unknown
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Unknown result type (might be due to invalid IL or missing references)
			float num = base.Width - 44f;
			float num2 = (0f - num) / 2f;
			_enabled = AddToggle(gui, font, headerColor, AtlasStrings.Get("survey.enable"), -150f, y, delegate(bool value)
			{
				_settings.SurveyRulesEnabled.Value = value;
				Refresh();
			}, 170f);
			y -= 32f;
			float num3 = num / 3f;
			string[] array = new string[3] { "Pending", "Rejected", "Rules" };
			for (int num4 = 0; num4 < array.Length; num4++)
			{
				int captured = num4;
				_viewButtons[num4] = AddButton(gui, array[num4], num2 + num3 * ((float)num4 + 0.5f), y, num3 - 4f, 26f, delegate
				{
					_view = (View)captured;
					_page = 0;
					_pendingConfirm = "";
					Refresh();
				});
			}
			y -= 32f;
			_note = AddBody(gui, font, "", 12, Color.white, ref y, 30f);
			_status = AddBody(gui, font, "", 12, new Color(0.85f, 1f, 0.85f, 1f), ref y, 66f);
			y -= 12f;
			for (int num5 = 0; num5 < 5; num5++)
			{
				int captured2 = num5;
				GameObject val = new GameObject("CCSurveyRow", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(base.Panel.transform, false);
				RectTransform val2 = (RectTransform)val.transform;
				val2.anchorMin = new Vector2(0.5f, 1f);
				val2.anchorMax = new Vector2(0.5f, 1f);
				val2.anchoredPosition = new Vector2(0f, y);
				val2.sizeDelta = new Vector2(num, 26f);
				Text component = gui.CreateText("", val.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-34f, 0f), font, 12, Color.white, false, Color.black, num - 72f, 26f, false).GetComponent<Text>();
				component.alignment = (TextAnchor)3;
				((Graphic)component).raycastTarget = false;
				_rowLabels[num5] = component;
				GameObject val3 = gui.CreateButton("+", val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-46f, 0f), 30f, 24f);
				_rowButtonALabels[num5] = val3.GetComponentInChildren<Text>();
				((UnityEvent)val3.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					RowAction(captured2, primary: true);
				});
				GameObject val4 = gui.CreateButton("-", val.transform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-14f, 0f), 30f, 24f);
				_rowButtonBLabels[num5] = val4.GetComponentInChildren<Text>();
				((UnityEvent)val4.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					RowAction(captured2, primary: false);
				});
				_rows[num5] = val;
				val.SetActive(false);
				y -= 34f;
			}
			y -= 4f;
			float num6 = num / 2f;
			_scanNowButton = ((Component)AddButton(gui, "Scan now", num2 + num6 * 0.5f, y, num6 - 4f, 26f, delegate
			{
				if (!_settings.SurveyRulesEnabled.Value)
				{
					Report("Enable the survey first — scanning only runs while it is on.");
				}
				else
				{
					_scanner()?.RequestImmediateScan();
					Report("Scanning around you now; new observations appear above within a second.");
					Refresh();
				}
			})).gameObject;
			_acceptAllButton = ((Component)AddButton(gui, "Accept all", num2 + num6 * 1.5f, y, num6 - 4f, 26f, delegate
			{
				ConfirmedBulk("accept");
			})).gameObject;
			_restoreAllButton = ((Component)AddButton(gui, "Restore all", num2 + num6 * 0.5f, y, num6 - 4f, 26f, delegate
			{
				Report(_execute(new string[2] { "restore", "all" }));
				_page = 0;
				Refresh();
			})).gameObject;
			_addRuleInput = (_addRuleField = gui.CreateInputField(base.Panel.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(num2 + (num - 80f) / 2f, y), (ContentType)0, "new rule prefab pattern (bush*)", 12, num - 84f, 26f)).GetComponent<InputField>();
			_addRuleButton = ((Component)AddButton(gui, "Add", num2 + num - 40f, y, 76f, 26f, AddRuleClicked)).gameObject;
			y -= 30f;
			_rejectAllButton = ((Component)AddButton(gui, "Reject all", num2 + num6 * 0.5f, y, num6 - 4f, 26f, delegate
			{
				ConfirmedBulk("reject");
			})).gameObject;
			_addIconButton = ((Component)AddButton(gui, "", num2 + num6 * 0.5f, y, num6 - 4f, 26f, delegate
			{
				_addChoice = (_addChoice + 1) % AddChoices.Length;
				RefreshAddIconLabel();
			})).gameObject;
			_addIconLabel = _addIconButton.GetComponentInChildren<Text>();
			_reloadButton = ((Component)AddButton(gui, "Reload file", num2 + num6 * 1.5f - 36f, y, num6 - 76f, 26f, delegate
			{
				Report(_execute(new string[1] { "reload" }));
				_page = 0;
				Refresh();
			})).gameObject;
			_pageBack = ((Component)AddButton(gui, "◀", num2 + num - 66f, y, 28f, 26f, delegate
			{
				Turn(-1);
			})).gameObject;
			_pageForward = ((Component)AddButton(gui, "▶", num2 + num - 34f, y, 28f, 26f, delegate
			{
				Turn(1);
			})).gameObject;
			y -= 34f;
			_output = AddBody(gui, font, "", 12, Color.white, ref y, 44f);
		}

		private void AddRuleClicked()
		{
			string text = (((Object)(object)_addRuleInput != (Object)null) ? _addRuleInput.text.Trim() : "");
			if (text.Length == 0)
			{
				Report("Type a prefab pattern first — e.g. 'greydwarf_root*' ('*' matches name prefixes).");
				return;
			}
			var (text2, text3) = AddChoices[_addChoice];
			Report(_execute(new string[4] { "ruleadd", text, text2, text3 }));
			if ((Object)(object)_addRuleInput != (Object)null)
			{
				_addRuleInput.text = "";
			}
			Refresh();
		}

		private void Turn(int direction)
		{
			_page = Math.Max(0, _page + direction);
			Refresh();
		}

		protected override void OnShown()
		{
			if ((Object)(object)_enabled != (Object)null)
			{
				SetToggleSilently(_enabled, _settings.SurveyRulesEnabled.Value);
			}
			_pendingConfirm = "";
			_page = 0;
			RefreshAddIconLabel();
			Refresh();
		}

		public override void HandleFrame()
		{
			base.HandleFrame();
			if (base.IsVisible)
			{
				_refreshElapsed += Time.unscaledDeltaTime;
				if (_refreshElapsed >= 1f)
				{
					_refreshElapsed = 0f;
					Refresh();
				}
			}
		}

		private void RowAction(int index, bool primary)
		{
			int num = _page * 5 + index + 1;
			switch (_view)
			{
			case View.Pending:
				Report(_execute(new string[2]
				{
					primary ? "accept" : "reject",
					"id:" + _rowObservationIds[index].ToString("N")
				}));
				break;
			case View.Rejected:
				Report(_execute(new string[2]
				{
					primary ? "restore" : "acceptrejected",
					"key:" + _rowRejectedKeys[index]
				}));
				break;
			case View.Rules:
				if (primary)
				{
					bool flag = ItemIsEnabledRule(num - 1);
					Report(_execute(new string[2]
					{
						flag ? "ruleoff" : "ruleon",
						num.ToString()
					}));
				}
				else
				{
					Report(_execute(new string[2]
					{
						"ruledel",
						num.ToString()
					}));
				}
				break;
			}
			Refresh();
		}

		private bool ItemIsEnabledRule(int ruleIndex)
		{
			IReadOnlyList<SurveyRule> rules = _engine().Rules.Rules;
			if (ruleIndex >= 0 && ruleIndex < rules.Count)
			{
				return rules[ruleIndex].Enabled;
			}
			return false;
		}

		private void ConfirmedBulk(string action)
		{
			if (_pendingConfirm != action)
			{
				_pendingConfirm = action;
				Report(AtlasStrings.Get("survey.confirm") + " — " + action + " ALL pending observations.");
				return;
			}
			_pendingConfirm = "";
			Report(_execute(new string[2] { action, "all" }));
			Refresh();
		}

		private void RefreshAddIconLabel()
		{
			if ((Object)(object)_addIconLabel != (Object)null)
			{
				var (text, text2) = AddChoices[_addChoice];
				_addIconLabel.text = text2 + " (" + text + ")";
				_addIconLabel.fontSize = 11;
			}
		}

		private void Refresh()
		{
			SurveyEngine surveyEngine = _engine();
			int num = _view switch
			{
				View.Pending => _observations().Count, 
				View.Rejected => surveyEngine.Rejected.Count, 
				_ => surveyEngine.Rules.Rules.Count, 
			};
			int num2 = Math.Max(1, (num + 5 - 1) / 5);
			_page = Math.Min(_page, num2 - 1);
			RefreshChrome(num2);
			RefreshNoteAndStatus(surveyEngine, num, num2);
			RefreshRows(surveyEngine);
		}

		private void RefreshChrome(int pageCount)
		{
			GameObject? scanNowButton = _scanNowButton;
			if (scanNowButton != null)
			{
				scanNowButton.SetActive(_view == View.Pending);
			}
			GameObject? acceptAllButton = _acceptAllButton;
			if (acceptAllButton != null)
			{
				acceptAllButton.SetActive(_view == View.Pending);
			}
			GameObject? rejectAllButton = _rejectAllButton;
			if (rejectAllButton != null)
			{
				rejectAllButton.SetActive(_view == View.Pending);
			}
			GameObject? restoreAllButton = _restoreAllButton;
			if (restoreAllButton != null)
			{
				restoreAllButton.SetActive(_view == View.Rejected);
			}
			GameObject? addRuleField = _addRuleField;
			if (addRuleField != null)
			{
				addRuleField.SetActive(_view == View.Rules);
			}
			GameObject? addRuleButton = _addRuleButton;
			if (addRuleButton != null)
			{
				addRuleButton.SetActive(_view == View.Rules);
			}
			GameObject? addIconButton = _addIconButton;
			if (addIconButton != null)
			{
				addIconButton.SetActive(_view == View.Rules);
			}
			GameObject? reloadButton = _reloadButton;
			if (reloadButton != null)
			{
				reloadButton.SetActive(_view == View.Rules);
			}
			bool active = pageCount > 1;
			GameObject? pageBack = _pageBack;
			if (pageBack != null)
			{
				pageBack.SetActive(active);
			}
			GameObject? pageForward = _pageForward;
			if (pageForward != null)
			{
				pageForward.SetActive(active);
			}
			for (int i = 0; i < _viewButtons.Length; i++)
			{
				Text val = (((Object)(object)_viewButtons[i] != (Object)null) ? ((Component)_viewButtons[i]).GetComponentInChildren<Text>() : null);
				if ((Object)(object)val != (Object)null)
				{
					string text = i switch
					{
						1 => "Rejected", 
						0 => "Pending", 
						_ => "Rules", 
					};
					val.text = ((_view == (View)i) ? ("» " + text) : text);
				}
			}
		}

		private void RefreshNoteAndStatus(SurveyEngine engine, int itemCount, int pageCount)
		{
			string text = ((pageCount > 1) ? $" — page {_page + 1}/{pageCount}" : "");
			if ((Object)(object)_note != (Object)null)
			{
				Text note = _note;
				note.text = _view switch
				{
					View.Pending => AtlasStrings.Get("survey.note"), 
					View.Rejected => "Rejected observations stay here and never re-offer on their own.", 
					_ => "Rules decide what nearby objects become observations.", 
				};
			}
			if ((Object)(object)_status == (Object)null)
			{
				return;
			}
			switch (_view)
			{
			case View.Pending:
			{
				SurveyScanner surveyScanner = _scanner();
				string text2 = ((surveyScanner != null && surveyScanner.DisabledForSession) ? "Scanner FAILED this session (see log)" : (_settings.SurveyRulesEnabled.Value ? $"Scanning continuously ({_settings.SurveyScanRadius.Value:0} m around you)" : "Scanning OFF — enable above to start"));
				DateTime? dateTime = surveyScanner?.LastScanUtc;
				object obj;
				if (dateTime.HasValue)
				{
					DateTime valueOrDefault = dateTime.GetValueOrDefault();
					obj = $"Sweep {Math.Max(0, (int)(DateTime.UtcNow - valueOrDefault).TotalSeconds)}s ago: {surveyScanner.LastScanExamined} checked, {surveyScanner.LastScanAdded} new";
				}
				else
				{
					obj = "No sweep finished yet this session";
				}
				string text3 = (string)obj;
				_status.text = text2 + "\n" + text3 + $"\n{itemCount} pending{text}" + ((itemCount > 0) ? "\n+ accepts as a marker · − rejects" : "");
				break;
			}
			case View.Rejected:
				_status.text = $"{itemCount} rejected{text}" + ((itemCount > 0) ? "\n↩ returns to review · + accepts as a marker" : "");
				break;
			default:
				_status.text = $"{engine.Rules.Rules.Count} rule(s), {engine.Rules.Blacklist.Count} blocked{text}" + "\n⏻ toggles · ✕ deletes · add below.\nsurvey-rules.tsv stays the import/export.";
				break;
			}
		}

		private void RefreshRows(SurveyEngine engine)
		{
			IReadOnlyList<SurveyEngine.Observation> readOnlyList = _observations();
			for (int i = 0; i < 5; i++)
			{
				int num = _page * 5 + i;
				bool flag;
				switch (_view)
				{
				case View.Pending:
					flag = num < readOnlyList.Count;
					if (flag)
					{
						SurveyEngine.Observation observation = readOnlyList[num];
						_rowObservationIds[i] = observation.Id;
						_rowLabels[i].text = observation.SuggestedName + " [" + observation.Category + "]";
						_rowButtonALabels[i].text = "+";
						_rowButtonBLabels[i].text = "−";
					}
					break;
				case View.Rejected:
					flag = num < engine.Rejected.Count;
					if (flag)
					{
						SurveyEngine.RejectedObservation rejectedObservation = engine.Rejected[num];
						_rowRejectedKeys[i] = SurveyEngine.IdentityKey(rejectedObservation.PrefabName, rejectedObservation.Position);
						_rowLabels[i].text = rejectedObservation.SuggestedName + " [" + rejectedObservation.Category + "]";
						_rowButtonALabels[i].text = "↩";
						_rowButtonBLabels[i].text = "+";
					}
					break;
				default:
					flag = num < engine.Rules.Rules.Count;
					if (flag)
					{
						SurveyRule surveyRule = engine.Rules.Rules[num];
						_rowLabels[i].text = (surveyRule.Enabled ? "" : "(off) ") + surveyRule.Pattern + " → " + surveyRule.Category;
						_rowButtonALabels[i].text = "⏻";
						_rowButtonBLabels[i].text = "✕";
					}
					break;
				}
				_rows[i].SetActive(flag);
			}
		}

		private void Report(string message)
		{
			if ((Object)(object)_output != (Object)null)
			{
				_output.text = message;
			}
		}
	}
	internal sealed class SystemMarkersPanel : CcSidePanel
	{
		private static readonly (string LabelKey, string? RegistryIcon, int VanillaType)[] FilterRows = new(string, string, int)[7]
		{
			("", "vanilla:fire", 0),
			("", "vanilla:house", 1),
			("", "vanilla:hammer", 2),
			("", "vanilla:dot", 3),
			("", "vanilla:portal", 6),
			("system.death", null, 4),
			("system.boss", null, 9)
		};

		private readonly List<(int VanillaType, Toggle Toggle)> _filterToggles = new List<(int, Toggle)>();

		private Toggle? _publicPosition;

		public SystemMarkersPanel(ManualLogSource log)
			: base(log, "system.title", 320f, 480f)
		{
		}

		protected override void BuildContent(GUIManager gui, Font font, Color headerColor, ref float y)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			AddBody(gui, font, AtlasStrings.Get("system.note"), 12, Color.white, ref y, 34f);
			y -= 8f;
			(string, string, int)[] filterRows = FilterRows;
			for (int i = 0; i < filterRows.Length; i++)
			{
				(string, string, int) tuple = filterRows[i];
				string item = tuple.Item1;
				string item2 = tuple.Item2;
				int item3 = tuple.Item3;
				IconRegistry.IconDefinition definition;
				string label = ((item.Length > 0) ? AtlasStrings.Get(item) : (IconRegistry.TryResolve(item2, out definition) ? definition.DisplayName : (item2 ?? "")));
				int captured = item3;
				Toggle item4 = AddToggle(gui, font, Color.white, label, -120f, y, delegate(bool wanted)
				{
					if (MinimapReflection.TryGetIconFilterVisible(captured, out var visible) && visible != wanted)
					{
						MinimapReflection.TryToggleIconFilter(captured);
					}
				});
				_filterToggles.Add((item3, item4));
				y -= 34f;
			}
			y -= 8f;
			_publicPosition = AddToggle(gui, font, headerColor, AtlasStrings.Get("system.visibleToOthers"), -120f, y, delegate(bool wanted)
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					ZNet.instance.SetPublicReferencePosition(wanted);
				}
			});
			y -= 34f;
		}

		protected override void OnShown()
		{
			foreach (var (vanillaType, toggle) in _filterToggles)
			{
				if (MinimapReflection.TryGetIconFilterVisible(vanillaType, out var visible))
				{
					SetToggleSilently(toggle, visible);
				}
			}
			if ((Object)(object)_publicPosition != (Object)null)
			{
				bool value = false;
				try
				{
					value = (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsReferencePositionPublic();
				}
				catch
				{
				}
				SetToggleSilently(_publicPosition, value);
			}
		}
	}
}
namespace TheConcernedCat.ConcernedCartographer.Reporting
{
	internal sealed class CrashReportEvent
	{
		public static readonly HashSet<string> AllowedDataKeys = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Regex ExceptionTypePattern = new Regex("([A-Za-z_][A-Za-z0-9_.+`]*(?:Exception|Error))", RegexOptions.Compiled);

		public string Subsystem = "";

		public string ExceptionType = "";

		public string ExceptionMessage = "";

		public string StackTrace = "";

		public bool Fatal;

		public string Release = "";

		public string ModVersion = "";

		public string ValheimVersion = "";

		public string UnityVersion = "";

		public string BepInExVersion = "";

		public string JotunnVersion = "";

		public bool Multiplayer;

		public bool NoMap;

		public bool MapOpen;

		public readonly Dictionary<string, string> AllowedData = new Dictionary<string, string>();

		public string Fingerprint = "";

		public static CrashReportEvent Create(string subsystem, string rawText, bool fatal, CrashReportContext context, IReadOnlyDictionary<string, string>? exceptionData = null)
		{
			string text = rawText ?? "";
			int num = IndexOfStack(text);
			string text2 = ((num < 0) ? text : text.Substring(0, num));
			string text3 = ((num < 0) ? "" : text.Substring(num));
			Match match = ExceptionTypePattern.Match(text2);
			string text4 = (match.Success ? match.Groups[1].Value : "Error");
			string text5 = text2;
			if (match.Success)
			{
				int num2 = text2.IndexOf(':', match.Index + match.Length);
				if (num2 >= 0 && num2 + 1 < text2.Length)
				{
					text5 = text2.Substring(num2 + 1);
				}
			}
			CrashReportRuntimeState crashReportRuntimeState = context.SampleRuntimeState();
			CrashReportEvent crashReportEvent = new CrashReportEvent
			{
				Subsystem = CrashReportSanitizer.Sanitize(subsystem, 60),
				ExceptionType = CrashReportSanitizer.Sanitize(text4, 60),
				ExceptionMessage = CrashReportSanitizer.Sanitize(text5.Trim(), 2000),
				StackTrace = CrashReportSanitizer.Sanitize(text3.Trim(), 8000),
				Fatal = fatal,
				Release = context.Release,
				ModVersion = context.ModVersion,
				ValheimVersion = context.ValheimVersion,
				UnityVersion = context.UnityVersion,
				BepInExVersion = context.BepInExVersion,
				JotunnVersion = context.JotunnVersion,
				Multiplayer = crashReportRuntimeState.Multiplayer,
				NoMap = crashReportRuntimeState.NoMap,
				MapOpen = crashReportRuntimeState.MapOpen
			};
			if (exceptionData != null)
			{
				foreach (KeyValuePair<string, string> exceptionDatum in exceptionData)
				{
					if (AllowedDataKeys.Contains(exceptionDatum.Key))
					{
						crashReportEvent.AllowedData[exceptionDatum.Key] = CrashReportSanitizer.Sanitize(exceptionDatum.Value, 2000);
					}
				}
			}
			string text6 = crashReportEvent.StackTrace;
			int num3 = text6.IndexOf('\n');
			if (num3 > 0)
			{
				text6 = text6.Substring(0, num3);
			}
			if (text6.Length == 0)
			{
				text6 = ((crashReportEvent.ExceptionMessage.Length > 80) ? crashReportEvent.ExceptionMessage.Substring(0, 80) : crashReportEvent.ExceptionMessage);
			}
			crashReportEvent.Fingerprint = crashReportEvent.Subsystem + "|" + crashReportEvent.ExceptionType + "|" + text6.Trim();
			return crashReportEvent;
		}

		public string ToJson(string eventId, DateTime utcNow)
		{
			StringBuilder stringBuilder = new StringBuilder(1024);
			stringBuilder.Append('{');
			stringBuilder.Append("\"event_id\":").Append(Quote(eventId)).Append(',');
			stringBuilder.Append("\"timestamp\":").Append(Quote(utcNow.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture))).Append(',');
			stringBuilder.Append("\"platform\":\"csharp\",");
			stringBuilder.Append("\"level\":\"error\",");
			stringBuilder.Append("\"logger\":").Append(Quote(Subsystem)).Append(',');
			stringBuilder.Append("\"release\":").Append(Quote(Release)).Append(',');
			stringBuilder.Append("\"environment\":\"production\",");
			stringBuilder.Append("\"exception\":{\"values\":[{");
			stringBuilder.Append("\"type\":").Append(Quote(ExceptionType)).Append(',');
			stringBuilder.Append("\"value\":").Append(Quote(ExceptionMessage));
			stringBuilder.Append("}]},");
			stringBuilder.Append("\"tags\":{");
			stringBuilder.Append("\"cc.subsystem\":").Append(Quote(Subsystem)).Append(',');
			stringBuilder.Append("\"cc.fatal\":").Append(Quote(Fatal ? "true" : "false")).Append(',');
			stringBuilder.Append("\"cc.version\":").Append(Quote(ModVersion)).Append(',');
			stringBuilder.Append("\"game.valheim\":").Append(Quote(ValheimVersion)).Append(',');
			stringBuilder.Append("\"game.unity\":").Append(Quote(UnityVersion)).Append(',');
			stringBuilder.Append("\"env.bepinex\":").Append(Quote(BepInExVersion)).Append(',');
			stringBuilder.Append("\"env.jotunn\":").Append(Quote(JotunnVersion)).Append(',');
			stringBuilder.Append("\"session.multiplayer\":").Append(Quote(Multiplayer ? "true" : "false")).Append(',');
			stringBuilder.Append("\"session.nomap\":").Append(Quote(NoMap ? "true" : "false")).Append(',');
			stringBuilder.Append("\"session.map_open\":").Append(Quote(MapOpen ? "true" : "false"));
			stringBuilder.Append("},");
			stringBuilder.Append("\"extra\":{");
			stringBuilder.Append("\"cc_stack\":").Append(Quote(StackTrace));
			foreach (KeyValuePair<string, string> allowedDatum in AllowedData)
			{
				stringBuilder.Append(',').Append(Quote(allowedDatum.Key)).Append(':')
					.Append(Quote(allowedDatum.Value));
			}
			stringBuilder.Append("}}");
			return stringBuilder.ToString();
		}

		private static int IndexOfStack(string text)
		{
			int num = text.IndexOf("\n  at ", StringComparison.Ordinal);
			int num2 = text.IndexOf("\n at ", StringComparison.Ordinal);
			if (num < 0)
			{
				return num2;
			}
			if (num2 >= 0)
			{
				return Math.Min(num, num2);
			}
			return num;
		}

		private static string Quote(string value)
		{
			StringBuilder stringBuilder = new StringBuilder(value.Length + 2);
			stringBuilder.Append('"');
			foreach (char c in value)
			{
				switch (c)
				{
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("x4", CultureInfo.InvariantCulture));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			stringBuilder.Append('"');
			return stringBuilder.ToString();
		}
	}
	internal static class CrashReportSanitizer
	{
		public const int MaxSubsystemLength = 60;

		public const int MaxMessageLength = 2000;

		public const int MaxStackLength = 8000;

		private static readonly Regex Urls = new Regex("\\b(?:https?|wss?|ftp)://\\S+", RegexOptions.Compiled);

		private static readonly Regex CoordinatePairs = new Regex("\\(\\s*-?\\d+(?:\\.\\d+)?\\s*,\\s*-?\\d+(?:\\.\\d+)?(?:\\s*,\\s*-?\\d+(?:\\.\\d+)?)?\\s*\\)", RegexOptions.Compiled);

		private static readonly Regex WindowsPath = new Regex("[A-Za-z]:[\\\\/](?:[^\\\\/\\r\\n:*?\"<>|\\s]+[\\\\/])*([^\\\\/\\r\\n:*?\"<>|\\s]*)", RegexOptions.Compiled);

		private static readonly Regex UnixPath = new Regex("(?<![\\w.<])/(?:[^/\\s]+/)+([^/\\s]*)", RegexOptions.Compiled);

		private static readonly Regex UsersFragment = new Regex("\\bUsers[\\\\/][^\\\\/\\s]+", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		private static readonly Regex Ipv4 = new Regex("\\b\\d{1,3}(?:\\.\\d{1,3}){3}(?::\\d{1,5})?\\b", RegexOptions.Compiled);

		private static readonly Regex HexBlob = new Regex("\\b[A-Fa-f0-9]{32,}\\b", RegexOptions.Compiled);

		private static readonly Regex TokenBlob = new Regex("[A-Za-z0-9+/=_\\-]{40,}", RegexOptions.Compiled);

		private static readonly Regex LongDigits = new Regex("\\d{7,}", RegexOptions.Compiled);

		private static readonly Regex SaveFileNames = new Regex("[^\\\\/\\s\"']+\\.(db|fwl|fch)(\\.old|\\.bak)?\\b", RegexOptions.IgnoreCase | RegexOptions.Compiled);

		public static string Sanitize(string? text, int maxLength)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			string input = text;
			input = Urls.Replace(input, "<url>");
			input = CoordinatePairs.Replace(input, "(<pos>)");
			input = WindowsPath.Replace(input, "<path>/$1");
			input = UnixPath.Replace(input, "<path>/$1");
			input = UsersFragment.Replace(input, "Users/<user>");
			input = SaveFileNames.Replace(input, "<save>.$1");
			input = Ipv4.Replace(input, "<ip>");
			input = HexBlob.Replace(input, "<hex>");
			input = TokenBlob.Replace(input, "<token>");
			input = LongDigits.Replace(input, "<n>");
			if (input.Length > maxLength)
			{
				input = input.Substring(0, maxLength) + "…[truncated]";
			}
			return input;
		}
	}
	internal sealed class CrashReportThrottle
	{
		public const int DefaultMaxEventsPerSession = 10;

		private readonly HashSet<string> _sentFingerprints = new HashSet<string>();

		private readonly HashSet<string> _notifiedSubsystems = new HashSet<string>();

		private readonly int _maxEventsPerSession;

		private int _sent;

		public CrashReportThrottle(int maxEventsPerSession = 10)
		{
			_maxEventsPerSession = maxEventsPerSession;
		}

		public bool ShouldSend(string fingerprint)
		{
			if (_sent >= _maxEventsPerSession || !_sentFingerprints.Add(fingerprint))
			{
				return false;
			}
			_sent++;
			return true;
		}

		public bool ShouldNotify(string subsystem)
		{
			return _notifiedSubsystems.Add(subsystem);
		}
	}
	internal static class CrashSubsystems
	{
		private static readonly string[] Markers = new string[5] { " failed", " could not", " was disabled", " invariant", " error" };

		public static string Infer(string? logMessage)
		{
			string text = (logMessage ?? "").Trim();
			if (text.Length == 0)
			{
				return "unknown";
			}
			if (text.StartsWith("Could not ", StringComparison.OrdinalIgnoreCase))
			{
				return FirstWords(text.Substring("Could not ".Length), 3);
			}
			string text2 = text.ToLowerInvariant();
			int num = -1;
			string[] markers = Markers;
			foreach (string value in markers)
			{
				int num2 = text2.IndexOf(value, StringComparison.Ordinal);
				if (num2 > 0 && (num < 0 || num2 < num))
				{
					num = num2;
				}
			}
			string text3 = ((num > 0) ? text.Substring(0, num) : FirstWords(text, 3));
			text3 = text3.TrimEnd(':', ' ', '-');
			if (text3.Length == 0)
			{
				text3 = "unknown";
			}
			if (text3.Length <= 48)
			{
				return text3;
			}
			return text3.Substring(0, 48);
		}

		private static string FirstWords(string text, int count)
		{
			string[] array = text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			int count2 = Math.Min(count, array.Length);
			return string.Join(" ", array, 0, count2);
		}
	}
	internal readonly struct CrashReportRuntimeState
	{
		public bool Multiplayer { get; }

		public bool NoMap { get; }

		public bool MapOpen { get; }

		public CrashReportRuntimeState(bool multiplayer, bool noMap, bool mapOpen)
		{
			Multiplayer = multiplayer;
			NoMap = noMap;
			MapOpen = mapOpen;
		}
	}
	internal sealed class CrashReportContext
	{
		public string Release = "";

		public string ModVersion = "";

		public string ValheimVersion = "";

		public string UnityVersion = "";

		public string BepInExVersion = "";

		public string JotunnVersion = "";

		public Func<CrashReportRuntimeState>? RuntimeState;

		public CrashReportRuntimeState SampleRuntimeState()
		{
			try
			{
				return RuntimeState?.Invoke() ?? default(CrashReportRuntimeState);
			}
			catch
			{
				return default(CrashReportRuntimeState);
			}
		}
	}
	internal interface ICrashReporter : IDisposable
	{
		bool ConsentGranted { get; set; }

		void Initialize(CrashReportContext context);

		void CaptureException(string subsystem, string rawExceptionText);

		void CaptureFatalSubsystemFailure(string subsystem, string message);

		bool Flush(TimeSpan timeout);
	}
	internal sealed class NullCrashReporter : ICrashReporter, IDisposable
	{
		public bool ConsentGranted { get; set; }

		public void Initialize(CrashReportContext context)
		{
		}

		public void CaptureException(string subsystem, string rawExceptionText)
		{
		}

		public void CaptureFatalSubsystemFailure(string subsystem, string message)
		{
		}

		public bool Flush(TimeSpan timeout)
		{
			return true;
		}

		public void Dispose()
		{
		}
	}
	internal static class SafeLogText
	{
		public static string Describe(Exception exception)
		{
			if (exception != null)
			{
				return CrashReportSanitizer.Sanitize(exception.ToString(), 8000);
			}
			return "";
		}

		public static string Brief(Exception exception)
		{
			if (exception != null)
			{
				return exception.GetType().Name + ": " + CrashReportSanitizer.Sanitize(exception.Message, 2000);
			}
			return "";
		}
	}
	internal sealed class SentryCrashReporter : ICrashReporter, IDisposable
	{
		public const int MaxQueuedEvents = 8;

		private const int SendTimeoutMilliseconds = 5000;

		private readonly SentryDsn? _dsn;

		private readonly Func<string, string, string, bool>? _transport;

		private readonly CrashReportThrottle _throttle = new CrashReportThrottle();

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

		private readonly object _gate = new object();

		private CrashReportContext _context = new CrashReportContext();

		private Thread? _worker;

		private volatile bool _disposed;

		private volatile int _pending;

		public bool ConsentGranted { get; set; }

		public bool IsOperational
		{
			get
			{
				if (_dsn != null)
				{
					return !_disposed;
				}
				return false;
			}
		}

		public SentryCrashReporter(string dsn, Func<string, string, string, bool>? transport = null)
		{
			SentryDsn.TryParse(dsn, out _dsn);
			_transport = transport ?? ((_dsn == null) ? null : new Func<string, string, string, bool>(HttpPost));
		}

		public void Initialize(CrashReportContext context)
		{
			_context = context ?? new CrashReportContext();
		}

		public void CaptureException(string subsystem, string rawExceptionText)
		{
			Capture(subsystem, rawExceptionText, fatal: false);
		}

		public void CaptureFatalSubsystemFailure(string subsystem, string message)
		{
			Capture(subsystem, message, fatal: true);
		}

		public bool Flush(TimeSpan timeout)
		{
			try
			{
				DateTime dateTime = DateTime.UtcNow + timeout;
				while (_pending > 0 && DateTime.UtcNow < dateTime)
				{
					Thread.Sleep(25);
				}
				return _pending == 0;
			}
			catch
			{
				return false;
			}
		}

		public void Dispose()
		{
			_disposed = true;
			try
			{
				Flush(TimeSpan.FromSeconds(2.0));
				lock (_gate)
				{
					_queue.Clear();
					Monitor.PulseAll(_gate);
				}
			}
			catch
			{
			}
		}

		private void Capture(string subsystem, string rawText, bool fatal)
		{
			try
			{
				if (_disposed || !ConsentGranted || _dsn == null || _transport == null)
				{
					return;
				}
				CrashReportEvent crashReportEvent = CrashReportEvent.Create(subsystem, rawText, fatal, _context);
				if (!_throttle.ShouldSend(crashReportEvent.Fingerprint))
				{
					return;
				}
				string eventId = Guid.NewGuid().ToString("N");
				DateTime utcNow = DateTime.UtcNow;
				string item = SentryEnvelopeCodec.Build(crashReportEvent.ToJson(eventId, utcNow), eventId, utcNow);
				lock (_gate)
				{
					if (_queue.Count < 8)
					{
						_queue.Enqueue(item);
						_pending = _queue.Count;
						EnsureWorker();
						Monitor.Pulse(_gate);
					}
				}
			}
			catch
			{
			}
		}

		private void EnsureWorker()
		{
			Thread worker = _worker;
			if (worker == null || !worker.IsAlive)
			{
				_worker = new Thread(SendLoop)
				{
					IsBackground = true,
					Name = "CC-CrashReporter"
				};
				_worker.Start();
			}
		}

		private void SendLoop()
		{
			try
			{
				while (!_disposed)
				{
					string text = null;
					lock (_gate)
					{
						if (_queue.Count == 0)
						{
							Monitor.Wait(_gate, 1000);
						}
						if (_queue.Count > 0)
						{
							text = _queue.Dequeue();
						}
					}
					if (text != null)
					{
						try
						{
							_transport?.Invoke(_dsn.EnvelopeUrl, _dsn.AuthHeader, text);
						}
						catch
						{
						}
						lock (_gate)
						{
							_pending = _queue.Count;
						}
					}
				}
			}
			catch
			{
			}
		}

		private static bool HttpPost(string url, string authHeader, string body)
		{
			try
			{
				ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
			}
			catch
			{
			}
			HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
			httpWebRequest.Method = "POST";
			httpWebRequest.ContentType = "application/x-sentry-envelope";
			httpWebRequest.Headers["X-Sentry-Auth"] = authHeader;
			httpWebRequest.Timeout = 5000;
			httpWebRequest.ReadWriteTimeout = 5000;
			byte[] bytes = Encoding.UTF8.GetBytes(body);
			httpWebRequest.ContentLength = bytes.Length;
			using (Stream stream = httpWebRequest.GetRequestStream())
			{
				stream.Write(bytes, 0, bytes.Length);
			}
			using HttpWebResponse httpWebResponse = (HttpWebResponse)httpWebRequest.GetResponse();
			return httpWebResponse.StatusCode >= HttpStatusCode.OK && httpWebResponse.StatusCode < HttpStatusCode.MultipleChoices;
		}
	}
	internal sealed class SentryDsn
	{
		public string EnvelopeUrl { get; }

		public string AuthHeader { get; }

		private SentryDsn(string envelopeUrl, string authHeader)
		{
			EnvelopeUrl = envelopeUrl;
			AuthHeader = authHeader;
		}

		public static bool TryParse(string? dsn, out SentryDsn? parsed)
		{
			parsed = null;
			if (string.IsNullOrWhiteSpace(dsn) || !Uri.TryCreate(dsn.Trim(), UriKind.Absolute, out Uri result) || (result.Scheme != "https" && result.Scheme != "http") || result.UserInfo.Length == 0)
			{
				return false;
			}
			string text = result.UserInfo.Split(new char[1] { ':' })[0];
			string text2 = result.AbsolutePath.TrimEnd(new char[1] { '/' });
			int num = text2.LastIndexOf('/');
			string text3 = ((num >= 0) ? text2.Substring(num + 1) : text2);
			if (text.Length == 0 || text3.Length == 0 || !long.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var _))
			{
				return false;
			}
			string text4 = ((num > 0) ? text2.Substring(0, num) : "");
			string text5 = (result.IsDefaultPort ? result.Host : (result.Host + ":" + result.Port.ToString(CultureInfo.InvariantCulture)));
			string envelopeUrl = result.Scheme + "://" + text5 + text4 + "/api/" + text3 + "/envelope/";
			string authHeader = "Sentry sentry_version=7, sentry_client=cc-crash/1, sentry_key=" + text;
			parsed = new SentryDsn(envelopeUrl, authHeader);
			return true;
		}
	}
	internal static class SentryEnvelopeCodec
	{
		public static string Build(string eventJson, string eventId, DateTime sentAtUtc)
		{
			int byteCount = Encoding.UTF8.GetByteCount(eventJson);
			string text = sentAtUtc.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture);
			return "{\"event_id\":\"" + eventId + "\",\"sent_at\":\"" + text + "\"}\n{\"type\":\"event\",\"length\":" + byteCount.ToString(CultureInfo.InvariantCulture) + "}\n" + eventJson;
		}
	}
	internal static class SupportReportComposer
	{
		public const string Header = "# Concerned Cartographer support report (sanitized: no positions, names, notes, world identifiers, or file paths)";

		public const string AbsentStatus = "absent";

		public static string UnreadableStatus(Exception exception)
		{
			return "unreadable: " + ((exception == null) ? "unknown" : exception.GetType().Name);
		}

		public static string DescribeSidecar(string suffix, IReadOnlyList<string> contentLines, long sizeBytes)
		{
			string text = ((suffix == ".roads.tsv") ? Describe(RoadAtlasCodec.Parse(contentLines)) : ((!(suffix == ".pins.tsv")) ? Describe(RouteCodec.Parse(contentLines)) : Describe(PinCodec.Parse(contentLines))));
			string arg = text;
			long num = (sizeBytes + 1023) / 1024;
			return $"{num} KB, {arg}";
		}

		public static List<string> Compose(DateTime generatedUtc, string pluginVersion, string effectiveConfig, IReadOnlyList<(string Suffix, string Status)> sidecars, int backupCount)
		{
			List<string> list = new List<string>
			{
				"# Concerned Cartographer support report (sanitized: no positions, names, notes, world identifiers, or file paths)",
				Scrub($"generated-utc: {generatedUtc:yyyy-MM-dd HH:mm:ss}Z"),
				Scrub("plugin-version: " + pluginVersion),
				Scrub("config: " + effectiveConfig)
			};
			foreach (var (text, text2) in sidecars)
			{
				list.Add(Scrub(text + ": " + text2));
			}
			list.Add(Scrub($"backups: {backupCount}"));
			return list;
		}

		private static string Describe(RoadAtlasCodec.ParseResult result)
		{
			int num = 0;
			foreach (RoadStroke stroke in result.Strokes)
			{
				num += stroke.Points.Count;
			}
			return $"{result.Strokes.Count} strokes, {num} points, {result.MalformedRows} malformed";
		}

		private static string Describe(PinCodec.ParseResult result)
		{
			return $"{result.Pins.Count} pins, {result.MalformedRows} malformed";
		}

		private static string Describe(RouteCodec.ParseResult result)
		{
			return $"{result.Routes.Count} routes, {result.MalformedRows} malformed";
		}

		private static string Scrub(string line)
		{
			return CrashReportSanitizer.Sanitize(line, 2000);
		}
	}
}
namespace TheConcernedCat.ConcernedCartographer.Atlas
{
	internal static class AtlasCompression
	{
		public static byte[] Compress(byte[] input)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionLevel.Fastest))
			{
				gZipStream.Write(input, 0, input.Length);
			}
			return memoryStream.ToArray();
		}

		public static bool TryDecompress(byte[] input, int maxOutputBytes, out byte[] output)
		{
			output = null;
			try
			{
				using MemoryStream stream = new MemoryStream(input, writable: false);
				using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
				using MemoryStream memoryStream = new MemoryStream();
				byte[] array = new byte[16384];
				int num = 0;
				int num2;
				while ((num2 = gZipStream.Read(array, 0, array.Length)) > 0)
				{
					num += num2;
					if (num > maxOutputBytes)
					{
						return false;
					}
					memoryStream.Write(array, 0, num2);
				}
				output = memoryStream.ToArray();
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
	internal readonly struct AtlasId : IEquatable<AtlasId>
	{
		public const string PinKind = "pin";

		public const string RouteKind = "route";

		public string Kind { get; }

		public Guid Value { get; }

		public bool IsEmpty => Value == Guid.Empty;

		public AtlasId(string kind, Guid value)
		{
			Kind = kind;
			Value = value;
		}

		public static AtlasId NewPin()
		{
			return new AtlasId("pin", Guid.NewGuid());
		}

		public static bool TryParse(string? text, out AtlasId id)
		{
			id = default(AtlasId);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			string[] array = text.Split(new char[1] { ':' });
			if (array.Length != 3 || array[0] != "cc" || array[1].Length == 0 || !Guid.TryParseExact(array[2], "N", out var result))
			{
				return false;
			}
			id = new AtlasId(array[1], result);
			return true;
		}

		public override string ToString()
		{
			return string.Format(CultureInfo.InvariantCulture, "cc:{0}:{1:N}", Kind, Value);
		}

		public bool Equals(AtlasId other)
		{
			if (string.Equals(Kind, other.Kind, StringComparison.Ordinal))
			{
				return Value == other.Value;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return Value.GetHashCode() ^ (Kind?.GetHashCode() ?? 0);
		}
	}
	internal static class AtlasLimits
	{
		public const long MaxRevision = 1000000000000L;

		public const int MaxNameLength = 200;

		public const int MaxCategoryLength = 100;

		public const int MaxIconIdLength = 100;

		public const int MaxNotesLength = 10000;

		public const int MaxTags = 64;

		public const int MaxTagLength = 64;

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

		public static string Cap(string value, int maxLength)
		{
			if (value.Length > maxLength)
			{
				return value.Substring(0, maxLength);
			}
			return value;
		}
	}
	internal sealed class AtlasPin
	{
		public AtlasId Id { get; }

		public long Revision { get; set; }

		public DateTime CreatedUtc { get; set; }

		public DateTime ModifiedUtc { get; set; }

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

		public string IconId { get; set; } = "vanilla:dot";

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

		public int? ColorArgb { get; set; }

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

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

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

		public AtlasPinStatus Status { get; set; }

		public bool Checked { get; set; }

		public AtlasScope Scope { get; set; } = AtlasScope.Private;

		public AtlasPinSource Source { get; set; } = AtlasPinSource.Managed;

		public bool Archived { get; set; }

		public bool Deleted { get; set; }

		public DateTime? DeletedUtc { get; set; }

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

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

		public RoadPoint Position { get; set; }

		public AtlasPin(AtlasId id)
		{
			Id = id;
		}

		public AtlasPin Clone()
		{
			AtlasPin atlasPin = new AtlasPin(Id);
			atlasPin.Revision = Revision;
			atlasPin.CreatedUtc = CreatedUtc;
			atlasPin.ModifiedUtc = ModifiedUtc;
			atlasPin.Name = Name;
			atlasPin.IconId = IconId;
			atlasPin.Category = Category;
			atlasPin.ColorArgb = ColorArgb;
			atlasPin.SizeScale = SizeScale;
			atlasPin.Notes = Notes;
			atlasPin.Status = Status;
			atlasPin.Checked = Checked;
			atlasPin.Scope = Scope;
			atlasPin.Source = Source;
			atlasPin.Archived = Archived;
			atlasPin.Deleted = Deleted;
			atlasPin.DeletedUtc = DeletedUtc;
			atlasPin.OwnerAuthor = OwnerAuthor;
			atlasPin.LastAuthor = LastAuthor;
			atlasPin.Position = Position;
			atlasPin.Tags.AddRange(Tags);
			return atlasPin;
		}

		public void CopyFrom(AtlasPin other)
		{
			Revision = other.Revision;
			CreatedUtc = other.CreatedUtc;
			ModifiedUtc = other.ModifiedUtc;
			Name = other.Name;
			IconId = other.IconId;
			Category = other.Category;
			ColorArgb = other.ColorArgb;
			SizeScale = other.SizeScale;
			Notes = other.Notes;
			Status = other.Status;
			Checked = other.Checked;
			Scope = other.Scope;
			Source = other.Source;
			Archived = other.Archived;
			Deleted = other.Deleted;
			DeletedUtc = other.DeletedUtc;
			OwnerAuthor = other.OwnerAuthor;
			LastAuthor = other.LastAuthor;
			Position = other.Position;
			Tags.Clear();
			Tags.AddRange(other.Tags);
		}
	}
	internal enum AtlasPinSource
	{
		Managed = 1,
		AdoptedVanilla,
		Generated,
		Imported
	}
	internal enum AtlasPinStatus
	{
		None,
		Todo,
		InProgress,
		Done,
		Warning
	}
	internal enum RouteKind
	{
		Freehand = 1,
		Waypoint
	}
	internal enum RouteStyle
	{
		Solid = 1,
		Dashed,
		Dotted
	}
	internal enum RouteStatus
	{
		Planned = 1,
		Active,
		Done
	}
	internal sealed class AtlasRoute
	{
		public AtlasId Id { get; }

		public long Revision { get; set; }

		public DateTime CreatedUtc { get; set; }

		public DateTime ModifiedUtc { get; set; }

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

		public RouteKind Kind { get; set; } = RouteKind.Freehand;

		public RouteStyle Style { get; set; } = RouteStyle.Solid;

		public RouteStatus Status { get; set; } = RouteStatus.Planned;

		public int? ColorArgb { get; set; }

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

		public AtlasScope Scope { get; set; } = AtlasScope.Private;

		public bool Locked { get; set; }

		public bool Archived { get; set; }

		public bool Deleted { get; set; }

		public DateTime? DeletedUtc { get; set; }

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

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

		public List<RoadPoint> Points { get; } = new List<RoadPoint>();

		public AtlasRoute(AtlasId id)
		{
			Id = id;
		}

		public AtlasRoute Clone()
		{
			AtlasRoute atlasRoute = new AtlasRoute(Id);
			atlasRoute.Revision = Revision;
			atlasRoute.CreatedUtc = CreatedUtc;
			atlasRoute.ModifiedUtc = ModifiedUtc;
			atlasRoute.Name = Name;
			atlasRoute.Kind = Kind;
			atlasRoute.Style = Style;
			atlasRoute.Status = Status;
			atlasRoute.ColorArgb = ColorArgb;
			atlasRoute.Notes = Notes;
			atlasRoute.Scope = Scope;
			atlasRoute.Locked = Locked;
			atlasRoute.Archived = Archived;
			atlasRoute.Deleted = Deleted;
			atlasRoute.DeletedUtc = DeletedUtc;
			atlasRoute.OwnerAuthor = OwnerAuthor;
			atlasRoute.LastAuthor = LastAuthor;
			atlasRoute.Points.AddRange(Points);
			return atlasRoute;
		}

		public void CopyFrom(AtlasRoute other)
		{
			Revision = other.Revision;
			CreatedUtc = other.CreatedUtc;
			ModifiedUtc = other.ModifiedUtc;
			Name = other.Name;
			Kind = other.Kind;
			Style = other.Style;
			Status = other.Status;
			ColorArgb = other.ColorArgb;
			Notes = other.Notes;
			Scope = other.Scope;
			Locked = other.Locked;
			Archived = other.Archived;
			Deleted = other.Deleted;
			DeletedUtc = other.DeletedUtc;
			OwnerAuthor = other.OwnerAuthor;
			LastAuthor = other.LastAuthor;
			Points.Clear();
			Points.AddRange(other.Points);
		}
	}
	internal enum AtlasScope
	{
		Private = 1,
		Table,
		Server
	}
	internal static class AtlasStrings
	{
		public const string TemplateHeader = "# ConcernedCartographer strings v1 — key<TAB>translation (missing keys fall back to English)";

		private static readonly Dictionary<string, string> English = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["workbench.title"] = "Pin Workbench",
			["workbench.vanillaPin"] = "Vanilla marker",
			["workbench.foreignPin"] = "Foreign pin",
			["workbench.foreignInfo"] = "owned by the game or another mod; Concerned Cartographer never edits it.",
			["workbench.adoptInfo"] = "Keep this existing marker and enable Concerned Cartographer editing, notes, categories and atlas features. Its map position is preserved.",
			["workbench.adopt"] = "Upgrade & Edit",
			["workbench.apply"] = "Apply",
			["workbench.delete"] = "Delete",
			["workbench.close"] = "Close",
			["workbench.saved"] = "Saved.",
			["workbench.name"] = "Name",
			["workbench.icon"] = "Icon",
			["workbench.category"] = "Category",
			["workbench.color"] = "Color hex",
			["workbench.size"] = "Size 0.5-2",
			["workbench.tags"] = "Tags (a, b)",
			["workbench.notes"] = "Notes",
			["workbench.status"] = "Status",
			["workbench.scope"] = "Scope",
			["workbench.checked"] = "Crossed off",
			["workbench.customIcon"] = "Custom: {0}",
			["workbench.keepCustomIcon"] = "Keep custom ({0})",
			["workbench.sizeMeta"] = "Size (metadata)",
			["workbench.colorMeta"] = "Color hex (metadata)",
			["workbench.reset"] = "Reset",
			["drawer.title"] = "Atlas",
			["drawer.layers"] = "Layers",
			["drawer.dirtRoads"] = "Dirt roads",
			["drawer.pavedRoads"] = "Paved roads",
			["drawer.pins"] = "Pins",
			["drawer.clustering"] = "Clustering",
			["drawer.search"] = "Search",
			["drawer.go"] = "Go",
			["drawer.clearFilter"] = "Clear filter",
			["drawer.views"] = "Views",
			["drawer.save"] = "Save",
			["drawer.placeholders"] = "Routes and Sharing live on the map toolbar: [Routes] · [Share]",
			["drawer.privacy"] = "Privacy",
			["toolbar.atlas"] = "Atlas",
			["toolbar.markers"] = "Markers",
			["toolbar.routes"] = "Routes",
			["toolbar.survey"] = "Survey",
			["toolbar.share"] = "Share",
			["toolbar.quickpin"] = "Quick Pin",
			["toolbar.settings"] = "Settings",
			["system.title"] = "System Markers",
			["system.note"] = "Filters change map visibility only — nothing is ever deleted.",
			["system.visibleToOthers"] = "Visible to other players",
			["system.death"] = "Death markers",
			["system.boss"] = "Boss markers",
			["share.instructions"] = "Broadcast your shared scope; preview an inbox entry, then apply with an explicit conflict choice.",
			["routes.title"] = "Routes",
			["routes.explainer"] = "Routes are map planning overlays: draw or waypoint a plan, style and share it. They never move your character.",
			["routes.nameHint"] = "new route name",
			["routes.freeDraw"] = "Free Draw",
			["routes.waypoints"] = "Waypoints",
			["routes.erase"] = "Erase",
			["routes.finish"] = "Finish",
			["routes.snap"] = "Snap to roads",
			["routes.modeDraw"] = "DRAWING \"{0}\" — hold LMB on the map to draw; release ends that stroke. Finish or Esc exits.",
			["routes.modeWaypoint"] = "WAYPOINTS \"{0}\" — click the map to add points. Finish or Esc exits.",
			["routes.modeErase"] = "ERASING — hold LMB over route ink on the map. Finish or Esc exits.",
			["routes.mergePick"] = "Merge: click the route to fold INTO \"{0}\".",
			["survey.title"] = "Survey",
			["survey.enable"] = "Survey rules enabled",
			["survey.note"] = "Matches are observations only — nothing becomes a marker until you accept it.",
			["survey.confirm"] = "Click again to confirm",
			["share.title"] = "Share",
			["share.now"] = "Share now",
			["settings.title"] = "Settings",
			["settings.emailLine"] = "Bugs: GitHub issues · Private/security: support@theconcernedcat.com",
			["quickpin.armed"] = "Quick Pin armed — look at an object and click to capture. Esc to cancel.",
			["quickpin.cancelled"] = "Quick Pin cancelled.",
			["privacy.consentTitle"] = "Help improve Concerned Cartographer",
			["privacy.consentQuestion"] = "Would you like to send anonymous crash reports when Concerned Cartographer encounters an error?",
			["privacy.consentSent"] = "Sent: Concerned Cartographer version/release, Valheim/Unity/BepInEx/Jötunn versions, the affected subsystem, the exception type, and a sanitized stack trace.",
			["privacy.consentNever"] = "Never sent: Steam or player identity, character or world names, world seeds, server addresses or passwords, IP addresses (also scrubbed by the provider), map coordinates, pin names/notes/tags, route names, saves, screenshots, or your log file.",
			["privacy.consentProvider"] = "Provider: Sentry   ·   No gameplay analytics",
			["privacy.consentYes"] = "Send anonymous crash reports",
			["privacy.consentNo"] = "No thanks",
			["privacy.consentLearnMore"] = "Learn more",
			["privacy.settingsState"] = "Send anonymous crash reports: {0}",
			["privacy.turnOn"] = "Turn on",
			["privacy.turnOff"] = "Turn off",
			["privacy.noticeSent"] = "Concerned Cartographer disabled {0} after an unexpected error. An anonymous crash report was sent.",
			["privacy.noticeOff"] = "Concerned Cartographer disabled {0} after an unexpected error. Crash reporting is off. Enable it under CC Atlas → Privacy, or use 'cc_atlas support'.",
			["hud.quickPinNothing"] = "Nothing targeted to pin.",
			["hud.quickPinCreature"] = "Creatures are not pinned.",
			["hud.quickPinned"] = "Pinned \"{0}\".",
			["hud.quickPinDuplicate"] = "\"{0}\" is already pinned {1} m away.",
			["hud.surveyObservations"] = "Survey: {0} new observation(s) — review in [Survey]",
			["hud.syncReceived"] = "Atlas share received from {0} — review with cc_sync preview",
			["hud.onboarding"] = "Concerned Cartographer: use the Atlas and marker palette buttons on the large map. Select any marker to edit it.",
			["hud.atlasButton"] = "Atlas",
			["hud.atlasTooltip"] = "Concerned Cartographer Atlas — search, filter, routes and map layers (hotkey {0})",
			["hud.editHint"] = "{0} — Edit with Concerned Cartographer",
			["hud.upgradeEdit"] = "Upgrade & Edit",
			["hud.editPin"] = "Edit Pin",
			["palette.toggle"] = "Markers",
			["palette.title"] = "New Marker",
			["palette.search"] = "Search icons...",
			["palette.recent"] = "— Recent —",
			["palette.all"] = "— Markers —",
			["palette.place"] = "Double-click the map to place: {0}",
			["palette.pick"] = "Pick a marker, then double-click the map.",
			["hud.noMapNeedTable"] = "The atlas needs a cartography table nearby in a nomap world."
		};

		private static Dictionary<string, string> _overrides = new Dictionary<string, string>(StringComparer.Ordinal);

		public static IReadOnlyDictionary<string, string> Defaults => English;

		public static void LoadOverrides(Dictionary<string, string> overrides)
		{
			_overrides = overrides ?? new Dictionary<string, string>(StringComparer.Ordinal);
		}

		public static string Get(string key)
		{
			if (_overrides.TryGetValue(key, out string value) && !string.IsNullOrEmpty(value))
			{
				return value;
			}
			if (!English.TryGetValue(key, out string value2))
			{
				return key;
			}
			return value2;
		}

		public static string Format(string key, params object[] arguments)
		{
			try
			{
				return string.Format(Get(key), arguments);
			}
			catch (FormatException)
			{
				string value;
				return English.TryGetValue(key, out value) ? string.Format(value, arguments) : key;
			}
		}

		public static IEnumerable<string> TranslatorTemplate()
		{
			yield return "# ConcernedCartographer strings v1 — key<TAB>translation (missing keys fall back to English)";
			foreach (KeyValuePair<string, string> item in English)
			{
				yield return item.Key + "\t" + AtlasText.Escape(item.Value);
			}
		}

		public static Dictionary<string, string> ParseOverrides(IEnumerable<string> lines, out int skippedRows)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			skippedRows = 0;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				int num = text.IndexOf('\t');
				if (num <= 0 || num == text.Length - 1)
				{
					skippedRows++;
					continue;
				}
				string key = text.Substring(0, num);
				if (!English.ContainsKey(key))
				{
					skippedRows++;
				}
				else
				{
					dictionary[key] = AtlasText.Unescape(text.Substring(num + 1));
				}
			}
			return dictionary;
		}
	}
	internal static class AtlasText
	{
		public static string Escape(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				switch (c)
				{
				case '%':
					stringBuilder.Append("%25");
					break;
				case '\t':
					stringBuilder.Append("%09");
					break;
				case '\n':
					stringBuilder.Append("%0A");
					break;
				case '\r':
					stringBuilder.Append("%0D");
					break;
				case ',':
					stringBuilder.Append("%2C");
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			return stringBuilder.ToString();
		}

		public static string Unescape(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '%' && i + 2 < value.Length && TryParseHex(value[i + 1], value[i + 2], out var decoded))
				{
					stringBuilder.Append(decoded);
					i += 2;
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		public static string SanitizeDisplay(string? value, int maxLength)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(Math.Min(value.Length, maxLength));
			bool flag = false;
			foreach (char c in value)
			{
				switch (c)
				{
				case '<':
					flag = true;
					continue;
				case '>':
					flag = false;
					continue;
				default:
					if (flag || char.IsControl(c))
					{
						continue;
					}
					stringBuilder.Append(c);
					if (stringBuilder.Length < maxLength)
					{
						continue;
					}
					break;
				}
				break;
			}
			return stringBuilder.ToString().Trim();
		}

		public static string JoinTags(IEnumerable<string> tags)
		{
			List<string> list = new List<string>();
			foreach (string tag in tags)
			{
				string text = tag.Trim();
				if (text.Length > 0)
				{
					list.Add(Escape(text));
				}
			}
			return string.Join(",", list);
		}

		public static List<string> SplitTags(string? joined)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(joined))
			{
				return list;
			}
			string[] array = joined.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = Unescape(array[i]).Trim();
				if (text.Length > 0 && !list.Contains(text))
				{
					list.Add(text);
				}
			}
			return list;
		}

		private static bool TryParseHex(char high, char low, out char decoded)
		{
			int num = HexValue(high);
			int num2 = HexValue(low);
			if (num < 0 || num2 < 0)
			{
				decoded = '\0';
				return false;
			}
			decoded = (char)((num << 4) | num2);
			return true;
		}

		private static int HexValue(char character)
		{
			if (character >= '0' && character <= '9')
			{
				return character - 48;
			}
			if (character >= 'A' && character <= 'F')
			{
				return character - 65 + 10;
			}
			if (character >= 'a' && character <= 'f')
			{
				return character - 97 + 10;
			}
			return -1;
		}
	}
	internal sealed class DefaultPanelRule
	{
		private bool _armed = true;

		public bool IsArmed => _armed;

		public void NoteMapClosed()
		{
			_armed = true;
		}

		public bool ShouldAutoOpen(bool paletteAvailable, bool anySurfaceVisible)
		{
			if (!_armed)
			{
				return false;
			}
			_armed = false;
			if (paletteAvailable)
			{
				return !anySurfaceVisible;
			}
			return false;
		}
	}
	internal sealed class FreeDrawStrokeGate
	{
		public enum DecisionKind
		{
			None,
			StartStroke,
			Append,
			DropBuffer,
			EndStroke
		}

		public readonly struct Decision
		{
			public DecisionKind Kind { get; }

			public RoadPoint StrokeStart { get; }

			public Decision(DecisionKind kind, RoadPoint strokeStart)
			{
				Kind = kind;
				StrokeStart = strokeStart;
			}
		}

		private readonly float _minimumTravelMeters;

		private RoadPoint _bufferedStart;

		private bool _buffering;

		private bool _strokeLive;

		public bool StrokeLive => _strokeLive;

		public FreeDrawStrokeGate(float minimumTravelMeters = 2f)
		{
			_minimumTravelMeters = minimumTravelMeters;
		}

		public Decision Observe(bool held, RoadPoint cursor)
		{
			if (!held)
			{
				if (_strokeLive)
				{
					_strokeLive = false;
					return new Decision(DecisionKind.EndStroke, default(RoadPoint));
				}
				if (_buffering)
				{
					_buffering = false;
					return new Decision(DecisionKind.DropBuffer, default(RoadPoint));
				}
				return new Decision(DecisionKind.None, default(RoadPoint));
			}
			if (_strokeLive)
			{
				return new Decision(DecisionKind.Append, default(RoadPoint));
			}
			if (!_buffering)
			{
				_buffering = true;
				_bufferedStart = cursor;
				return new Decision(DecisionKind.None, default(RoadPoint));
			}
			if (_bufferedStart.HorizontalDistanceTo(in cursor) >= _minimumTravelMeters)
			{
				_buffering = false;
				_strokeLive = true;
				return new Decision(DecisionKind.StartStroke, _bufferedStart);
			}
			return new Decision(DecisionKind.None, default(RoadPoint));
		}

		public void Reset()
		{
			_buffering = false;
			_strokeLive = false;
		}
	}
	internal static class IconRegistry
	{
		public sealed class IconDefinition
		{
			public string Id { get; }

			public string DisplayName { get; }

			public string DefaultCategory { get; }

			public int VanillaType { get; }

			public string Keywords { get; }

			public string SpriteKey { get; }

			public bool HasCustomSprite => SpriteKey.Length > 0;

			public IconDefinition(string id, string displayName, string defaultCategory, int vanillaType, string keywords, string spriteKey = "")
			{
				Id = id;
				DisplayName = displayName;
				DefaultCategory = defaultCategory;
				VanillaType = vanillaType;
				Keywords = keywords;
				SpriteKey = spriteKey;
			}
		}

		public const string DefaultIconId = "vanilla:dot";

		public const int FallbackVanillaType = 3;

		private static readonly IconDefinition[] Definitions = new IconDefinition[17]
		{
			new IconDefinition("vanilla:fire", "Fire", "Camp", 0, "fire camp bonfire spawn"),
			new IconDefinition("vanilla:house", "House", "Base", 1, "house base home village building"),
			new IconDefinition("vanilla:hammer", "Hammer", "Work", 2, "hammer crafting work mine quarry"),
			new IconDefinition("vanilla:dot", "Dot", "General", 3, "dot ball marker generic default"),
			new IconDefinition("vanilla:portal", "Portal", "Travel", 6, "portal travel teleport gate"),
			new IconDefinition("cc:road", "Road / Junction", "Infrastructure", 3, "road path street junction crossing signpost", "cc-road"),
			new IconDefinition("cc:harbor", "Harbor / Anchor", "Travel", 3, "harbor port dock ship boat anchor", "cc-harbor"),
			new IconDefinition("cc:resource", "Resource", "Resources", 2, "resource ore wood berries deposit gather", "cc-resource"),
			new IconDefinition("cc:danger", "Danger", "Danger", 0, "danger enemy spawner warning skull", "cc-danger"),
			new IconDefinition("cc:farm", "Farm", "Base", 1, "farm crops cultivated animals sprout", "cc-farm"),
			new IconDefinition("cc:mine", "Mine", "Resources", 2, "mine pickaxe quarry ore tunnel", "cc-mine"),
			new IconDefinition("cc:fishing", "Fishing", "Resources", 3, "fishing fish spot water catch", "cc-fishing"),
			new IconDefinition("cc:camp", "Camp", "Camp", 0, "camp tent shelter rest outpost", "cc-camp"),
			new IconDefinition("cc:travel", "Travel", "Travel", 6, "travel route direction arrow waypoint", "cc-travel"),
			new IconDefinition("cc:trader", "Trader / Shop", "Points of interest", 1, "trader shop merchant haldor coins", "cc-trader"),
			new IconDefinition("cc:dungeon", "Dungeon / Cave", "Dungeons", 0, "dungeon cave crypt entrance burial", "cc-dungeon"),
			new IconDefinition("cc:objective", "Objective / Star", "Points of interest", 3, "objective star goal quest important", "cc-objective")
		};

		private static readonly Dictionary<string, IconDefinition> ById = BuildIndex();

		public static IReadOnlyList<IconDefinition> All => Definitions;

		public static bool TryResolve(string? iconId, out IconDefinition definition)
		{
			if (!string.IsNullOrEmpty(iconId) && ById.TryGetValue(iconId, out definition))
			{
				return true;
			}
			definition = ById["vanilla:dot"];
			return false;
		}

		public static int ResolveVanillaType(string? iconId)
		{
			if (!TryResolve(iconId, out IconDefinition definition))
			{
				return 3;
			}
			return definition.VanillaType;
		}

		public static string FromVanillaType(int vanillaType)
		{
			IconDefinition[] definitions = Definitions;
			foreach (IconDefinition iconDefinition in definitions)
			{
				if (iconDefinition.VanillaType == vanillaType && iconDefinition.Id.StartsWith("vanilla:", StringComparison.Ordinal))
				{
					return iconDefinition.Id;
				}
			}
			return "vanilla:dot";
		}

		public static List<IconDefinition> Search(string? query)
		{
			List<IconDefinition> list = new List<IconDefinition>();
			string text = (query ?? "").Trim().ToLowerInvariant();
			IconDefinition[] definitions = Definitions;
			foreach (IconDefinition iconDefinition in definitions)
			{
				if (text.Length == 0 || iconDefinition.Id.ToLowerInvariant().Contains(text) || iconDefinition.DisplayName.ToLowerInvariant().Contains(text) || iconDefinition.Keywords.Contains(text))
				{
					list.Add(iconDefinition);
				}
			}
			return list;
		}

		private static Dictionary<string, IconDefinition> BuildIndex()
		{
			Dictionary<string, IconDefinition> dictionary = new Dictionary<string, IconDefinition>(StringComparer.Ordinal);
			IconDefinition[] definitions = Definitions;
			foreach (IconDefinition iconDefinition in definitions)
			{
				dictionary.Add(iconDefinition.Id, iconDefinition);
			}
			return dictionary;
		}
	}
	internal sealed class MapSessionTracker
	{
		public int Generation { get; private set; }

		public bool Bound { get; private set; }

		public string LastTransitionReason { get; private set; } = "none";

		public int NoteTransition(string reason)
		{
			Generation++;
			Bound = false;
			LastTransitionReason = reason;
			return Generation;
		}

		public void NoteBound()
		{
			Bound = true;
		}
	}
	internal sealed class ModalInputBlock
	{
		private readonly Action<bool> _applyBlock;

		public bool Owned { get; private set; }

		public ModalInputBlock(Action<bool> applyBlock)
		{
			_applyBlock = applyBlock ?? throw new ArgumentNullException("applyBlock");
		}

		public void Acquire()
		{
			if (!Owned)
			{
				Owned = true;
				_applyBlock(obj: true);
			}
		}

		public void Release()
		{
			if (Owned)
			{
				Owned = false;
				_applyBlock(obj: false);
			}
		}
	}
	internal static class NameHumanizer
	{
		private static readonly Dictionary<string, string> CompoundWords = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["silvervein"] = "Silver Vein",
			["mudpile"] = "Mud Pile",
			["gucksack"] = "Guck Sack",
			["trollcave"] = "Troll Cave",
			["sunkencrypt"] = "Sunken Crypt",
			["mountaincave"] = "Mountain Cave",
			["minerock"] = "Mine Rock",
			["raspberrybush"] = "Raspberry Bush",
			["blueberrybush"] = "Blueberry Bush",
			["cloudberrybush"] = "Cloudberry Bush",
			["beehive"] = "Beehive",
			["fircone"] = "Fir Cone",
			["pinecone"] = "Pine Cone"
		};

		public static string Humanize(string? rawName)
		{
			string text = QuickPinSuggester.CleanObjectName(rawName);
			if (text.Length == 0)
			{
				return "";
			}
			List<string> list = SplitTokens(text);
			for (int num = list.Count - 1; num >= 0; num--)
			{
				if (list.Count > 1 && IsPureDigits(list[num]))
				{
					list.RemoveAt(num);
				}
			}
			while (list.Count > 1 && (string.Equals(list[0], "pickable", StringComparison.OrdinalIgnoreCase) || string.Equals(list[0], "piece", StringComparison.OrdinalIgnoreCase)))
			{
				list.RemoveAt(0);
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string item in list)
			{
				string value2;
				string value = (CompoundWords.TryGetValue(item.ToLowerInvariant(), out value2) ? value2 : TitleCase(item));
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(value);
			}
			return stringBuilder.ToString();
		}

		private static List<string> SplitTokens(string cleaned)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			char c = '\0';
			foreach (char c2 in cleaned)
			{
				if ((c2 == ' ' || (char.IsUpper(c2) && char.IsLower(c)) || (char.IsDigit(c2) != char.IsDigit(c) && c != 0 && c2 != ' ')) && stringBuilder.Length > 0)
				{
					list.Add(stringBuilder.ToString());
					stringBuilder.Clear();
				}
				if (c2 != ' ')
				{
					stringBuilder.Append(c2);
				}
				c = c2;
			}
			if (stringBuilder.Length > 0)
			{
				list.Add(stringBuilder.ToString());
			}
			return list;
		}

		private static bool IsPureDigits(string token)
		{
			for (int i = 0; i < token.Length; i++)
			{
				if (!char.IsDigit(token[i]))
				{
					return false;
				}
			}
			return token.Length > 0;
		}

		private static string TitleCase(string token)
		{
			if (token.Length == 0)
			{
				return token;
			}
			return char.ToUpperInvariant(token[0]) + token.Substring(1).ToLowerInvariant();
		}
	}
	internal static class OrphanChromeRule
	{
		public readonly struct CandidateFacts
		{
			public bool IsLargeRootOrAbove { get; }

			public bool ContainsProtectedObject { get; }

			public bool HasLiveControl { get; }

			public bool HasLiveTextGraphic { get; }

			public CandidateFacts(bool isLargeRootOrAbove, bool containsProtectedObject, bool hasLiveControl, bool hasLiveTextGraphic)
			{
				IsLargeRootOrAbove = isLargeRootOrAbove;
				ContainsProtectedObject = containsProtectedObject;
				HasLiveControl = hasLiveControl;
				HasLiveTextGraphic = hasLiveTextGraphic;
			}
		}

		public const int MaxClimbSteps = 3;

		public static bool MayHide(in CandidateFacts facts)
		{
			if (!facts.IsLargeRootOrAbove && !facts.ContainsProtectedObject && !facts.HasLiveControl)
			{
				return !facts.HasLiveTextGraphic;
			}
			return false;
		}

		public static bool MustRestore(bool anyVanillaControlsWanted)
		{
			return anyVanillaControlsWanted;
		}
	}
	internal static class OverlayHandleRule
	{
		public static bool MustReresolve(bool hasCachedHandle, bool cachedTextureAlive)
		{
			if (hasCachedHandle)
			{
				return !cachedTextureAlive;
			}
			return true;
		}

		public static bool MayWrite(bool textureAliveAtResolve, bool textureAliveAtWrite)
		{
			return textureAliveAtResolve && textureAliveAtWrite;
		}
	}
	internal static class OverlayVisibilityRule
	{
		public static bool EffectiveTexture(bool userEnabled, bool vectorPresentationActive)
		{
			if (userEnabled)
			{
				return !vectorPresentationActive;
			}
			return false;
		}

		public static bool CheckboxShows(bool userEnabled)
		{
			return userEnabled;
		}
	}
	internal static class PaletteBirthResolution
	{
		public enum Action
		{
			AdoptBorn,
			AdoptReplacement,
			RecreateManaged,
			DropCancelled,
			DropForeign
		}

		public static Action Decide(bool bornStillOnMap, bool bornAdoptable, bool replacementAtPositionExists, string committedName)
		{
			if (bornStillOnMap)
			{
				if (!bornAdoptable)
				{
					return Action.DropForeign;
				}
				return Action.AdoptBorn;
			}
			if (replacementAtPositionExists)
			{
				return Action.AdoptReplacement;
			}
			if (!string.IsNullOrEmpty(committedName))
			{
				return Action.RecreateManaged;
			}
			return Action.DropCancelled;
		}
	}
	internal sealed class PaletteBirthTracker<THandle> where THandle : class
	{
		private THandle? _lastNaming;

		private THandle? _pending;

		public bool IsArmed { get; private set; }

		public string IconId { get; private set; } = "";

		public string Category { get; private set; } = "";

		public void Arm(string iconId, string category)
		{
			IsArmed = true;
			IconId = iconId;
			Category = category;
		}

		public void Disarm()
		{
			IsArmed = false;
			_pending = null;
		}

		public THandle? Observe(THandle? namingPin)
		{
			if (namingPin == _lastNaming)
			{
				return null;
			}
			THandle? pending = _pending;
			_pending = null;
			_lastNaming = namingPin;
			if (namingPin != null && IsArmed)
			{
				_pending = namingPin;
			}
			return pending;
		}

		public void Reset()
		{
			_lastNaming = null;
			_pending = null;
		}
	}
	internal static class PaletteScrollTuning
	{
		public const float WheelFactor = 3f;

		public const float MinimumStepPixels = 78f;

		public static float Scaled(float rc12Sensitivity)
		{
			float num = ((rc12Sensitivity > 0f) ? (rc12Sensitivity * 3f) : 78f);
			if (!(num >= 78f))
			{
				return 78f;
			}
			return num;
		}
	}
	internal static class PanelPositionRule
	{
		public static bool TryParse(string? stored, out float x, out float y)
		{
			x = 0f;
			y = 0f;
			if (string.IsNullOrWhiteSpace(stored))
			{
				return false;
			}
			string[] array = stored.Split(new char[1] { ',' });
			if (array.Length != 2)
			{
				return false;
			}
			if (!float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || !float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return false;
			}
			if (!IsFinite(result) || !IsFinite(result2))
			{
				return false;
			}
			x = result;
			y = result2;
			return true;
		}

		public static string Serialize(float x, float y)
		{
			return x.ToString("R", CultureInfo.InvariantCulture) + "," + y.ToString("R", CultureInfo.InvariantCulture);
		}

		public static (float X, float Y) Clamp(float x, float y, float panelWidth, float panelHeight, float uiScale, float canvasWidth, float canvasHeight)
		{
			float num = panelWidth * uiScale / 2f;
			float num2 = panelHeight * uiScale / 2f;
			float item = ClampAxis(x, num - canvasWidth, 0f - num);
			float item2 = ClampAxis(y, num2 - canvasHeight / 2f, canvasHeight / 2f - num2);
			return (X: item, Y: item2);
		}

		private static float ClampAxis(float value, float min, float max)
		{
			if (min > max)
			{
				return (min + max) / 2f;
			}
			if (value < min)
			{
				return min;
			}
			if (!(value > max))
			{
				return value;
			}
			return max;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	internal static class PinClusterer
	{
		public sealed class Cluster
		{
			public RoadPoint Center { get; }

			public string DominantIconId { get; }

			public string DominantCategory { get; }

			public List<AtlasPin> Members { get; }

			public Cluster(RoadPoint center, string dominantIconId, string dominantCategory, List<AtlasPin> members)
			{
				Center = center;
				DominantIconId = dominantIconId;
				DominantCategory = dominantCategory;
				Members = members;
			}
		}

		public sealed class Result
		{
			public List<AtlasPin> Singles { get; } = new List<AtlasPin>();

			public List<Cluster> Clusters { get; } = new List<Cluster>();
		}

		public static Result Compute(IEnumerable<AtlasPin> pins, float cellMeters, int minClusterSize = 3, ISet<Guid>? alwaysVisible = null)
		{
			Result result = new Result();
			if (cellMeters <= 0f)
			{
				result.Singles.AddRange(pins);
				return result;
			}
			SortedDictionary<long, List<AtlasPin>> sortedDictionary = new SortedDictionary<long, List<AtlasPin>>();
			foreach (AtlasPin pin in pins)
			{
				if (alwaysVisible != null && alwaysVisible.Contains(pin.Id.Value))
				{
					result.Singles.Add(pin);
					continue;
				}
				int num = (int)Math.Floor(pin.Position.X / cellMeters);
				int num2 = (int)Math.Floor(pin.Position.Z / cellMeters);
				long key = (long)(((ulong)(uint)num << 32) ^ (uint)num2);
				if (!sortedDictionary.TryGetValue(key, out var value))
				{
					value = new List<AtlasPin>();
					sortedDictionary.Add(key, value);
				}
				value.Add(pin);
			}
			foreach (KeyValuePair<long, List<AtlasPin>> item in sortedDictionary)
			{
				List<AtlasPin> value2 = item.Value;
				if (value2.Count < minClusterSize)
				{
					result.Singles.AddRange(value2);
					continue;
				}
				float num3 = 0f;
				float num4 = 0f;
				Dictionary<string, int> counts = new Dictionary<string, int>(StringComparer.Ordinal);
				Dictionary<string, int> counts2 = new Dictionary<string, int>(StringComparer.Ordinal);
				foreach (AtlasPin item2 in value2)
				{
					num3 += item2.Position.X;
					num4 += item2.Position.Z;
					Count(counts, item2.IconId);
					if (item2.Category.Length > 0)
					{
						Count(counts2, item2.Category);
					}
				}
				RoadPoint center = new RoadPoint(num3 / (float)value2.Count, 0f, num4 / (float)value2.Count);
				result.Clusters.Add(new Cluster(center, Dominant(counts), Dominant(counts2), value2));
			}
			return result;
		}

		private static void Count(Dictionary<string, int> counts, string key)
		{
			counts.TryGetValue(key, out var value);
			counts[key] = value + 1;
		}

		private static string Dominant(Dictionary<string, int> counts)
		{
			string text = "";
			int num = 0;
			foreach (KeyValuePair<string, int> count in counts)
			{
				if (count.Value > num || (count.Value == num && string.CompareOrdinal(count.Key, text) < 0))
				{
					text = count.Key;
					num = count.Value;
				}
			}
			return text;
		}
	}
	internal static class PinCodec
	{
		public sealed class ParseResult
		{
			public List<AtlasPin> Pins { get; }

			public int MalformedRows { get; }

			public int SupersededRows { get; }

			public ParseResult(List<AtlasPin> pins, int malformedRows, int supersededRows)
			{
				Pins = pins;
				MalformedRows = malformedRows;
				SupersededRows = supersededRows;
			}
		}

		public const string Header = "# ConcernedCartographer pins v2";

		private const string RowMarkerV1 = "1";

		private const string RowMarker = "2";

		private const int FieldCountV1 = 22;

		private const int FieldCount = 24;

		public static ParseResult Parse(IEnumerable<string> lines)
		{
			Dictionary<Guid, AtlasPin> dictionary = new Dictionary<Guid, AtlasPin>();
			List<Guid> list = new List<Guid>();
			int num = 0;
			int num2 = 0;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				AtlasPin value;
				if (!TryParseRow(text, out AtlasPin pin))
				{
					num++;
				}
				else if (dictionary.TryGetValue(pin.Id.Value, out value))
				{
					if (pin.Revision > value.Revision)
					{
						value.CopyFrom(pin);
					}
					else
					{
						num2++;
					}
				}
				else
				{
					dictionary.Add(pin.Id.Value, pin);
					list.Add(pin.Id.Value);
				}
			}
			List<AtlasPin> list2 = new List<AtlasPin>(list.Count);
			foreach (Guid item in list)
			{
				list2.Add(dictionary[item]);
			}
			return new ParseResult(list2, num, num2);
		}

		public static IEnumerable<string> Serialize(IEnumerable<AtlasPin> pins)
		{
			yield return "# ConcernedCartographer pins v2";
			foreach (AtlasPin pin in pins)
			{
				yield return SerializeRow(pin);
			}
		}

		public static string SerializeRow(AtlasPin pin)
		{
			return string.Join("\t", pin.Id.ToString(), pin.Revision.ToString(CultureInfo.InvariantCulture), pin.CreatedUtc.Ticks.ToString(CultureInfo.InvariantCulture), pin.ModifiedUtc.Ticks.ToString(CultureInfo.InvariantCulture), AtlasText.Escape(pin.Name), AtlasText.Escape(pin.IconId), AtlasText.Escape(pin.Category), pin.ColorArgb?.ToString(CultureInfo.InvariantCulture) ?? "", pin.SizeScale.ToString("R", CultureInfo.InvariantCulture), AtlasText.Escape(pin.Notes), AtlasText.JoinTags(pin.Tags), ((int)pin.Status).ToString(CultureInfo.InvariantCulture), pin.Checked ? "1" : "0", ((int)pin.Scope).ToString(CultureInfo.InvariantCulture), ((int)pin.Source).ToString(CultureInfo.InvariantCulture), pin.Archived ? "1" : "0", pin.Deleted ? "1" : "0", pin.DeletedUtc?.Ticks.ToString(CultureInfo.InvariantCulture) ?? "", AtlasText.Escape(pin.OwnerAuthor), AtlasText.Escape(pin.LastAuthor), pin.Position.X.ToString("R", CultureInfo.InvariantCulture), pin.Position.Y.ToString("R", CultureInfo.InvariantCulture), pin.Position.Z.ToString("R", CultureInfo.InvariantCulture), "2");
		}

		private static bool TryParseRow(string line, out AtlasPin pin)
		{
			pin = null;
			string[] array = line.Split(new char[1] { '\t' });
			bool num = array.Length == 22 && array[21] == "1";
			bool flag = array.Length == 24 && array[23] == "2";
			if (!num && !flag)
			{
				return false;
			}
			int num2 = (flag ? 20 : 18);
			string ownerAuthor = (flag ? AtlasText.Unescape(array[18]) : "");
			string lastAuthor = (flag ? AtlasText.Unescape(array[19]) : "");
			if (!AtlasId.TryParse(array[0], out var id) || !string.Equals(id.Kind, "pin", StringComparison.Ordinal) || !long.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result < 1 || result > 1000000000000L || !long.TryParse(array[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || !long.TryParse(array[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || !TryParseNullableInt(array[7], out var result4) || !float.TryParse(array[8], NumberStyles.Float, CultureInfo.InvariantCulture, out var result5) || !int.TryParse(array[11], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result6) || !Enum.IsDefined(typeof(AtlasPinStatus), result6) || !TryParseFlag(array[12], out var flag2) || !int.TryParse(array[13], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result7) || !Enum.IsDefined(typeof(AtlasScope), result7) || !int.TryParse(array[14], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result8) || !Enum.IsDefined(typeof(AtlasPinSource), result8) || !TryParseFlag(array[15], out var flag3) || !TryParseFlag(array[16], out var flag4) || !TryParseNullableTicks(array[17], out var result9) || !float.TryParse(array[num2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result10) || !float.TryParse(array[num2 + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result11) || !float.TryParse(array[num2 + 2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result12) || !AtlasLimits.IsFinite(result10) || !AtlasLimits.IsFinite(result11) || !AtlasLimits.IsFinite(result12) || !AtlasLimits.IsFinite(result5))
			{
				return false;
			}
			pin = new AtlasPin(id)
			{
				Revision = result,
				CreatedUtc = new DateTime(result2, DateTimeKind.Utc),
				ModifiedUtc = new DateTime(result3, DateTimeKind.Utc),
				Name = AtlasLimits.Cap(AtlasText.Unescape(array[4]), 200),
				IconId = AtlasLimits.Cap(AtlasText.Unescape(array[5]), 100),
				Category = AtlasLimits.Cap(AtlasText.Unescape(array[6]), 100),
				ColorArgb = result4,
				SizeScale = result5,
				Notes = AtlasLimits.Cap(AtlasText.Unescape(array[9]), 10000),
				Status = (AtlasPinStatus)result6,
				Checked = flag2,
				Scope = (AtlasScope)result7,
				Source = (AtlasPinSource)result8,
				Archived = flag3,
				Deleted = flag4,
				DeletedUtc = result9,
				OwnerAuthor = ownerAuthor,
				LastAuthor = lastAuthor,
				Position = new RoadPoint(result10, result11, result12)
			};
			foreach (string item in AtlasText.SplitTags(array[10]))
			{
				if (pin.Tags.Count >= 64)
				{
					break;
				}
				pin.Tags.Add(AtlasLimits.Cap(item, 64));
			}
			return true;
		}

		private static bool TryParseFlag(string value, out bool flag)
		{
			flag = value == "1";
			if (!(value == "1"))
			{
				return value == "0";
			}
			return true;
		}

		private static bool TryParseNullableInt(string value, out int? result)
		{
			if (value.Length == 0)
			{
				result = null;
				return true;
			}
			if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				result = result2;
				return true;
			}
			result = null;
			return false;
		}

		private static bool TryParseNullableTicks(string value, out DateTime? result)
		{
			if (value.Length == 0)
			{
				result = null;
				return true;
			}
			if (long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				result = new DateTime(result2, DateTimeKind.Utc);
				return true;
			}
			result = null;
			return false;
		}
	}
	internal sealed class PinOperations
	{
		private sealed class UndoRecord
		{
			public string Description { get; }

			public List<AtlasPin> Before { get; }

			public List<AtlasId> Created { get; }

			public UndoRecord(string description, List<AtlasPin> before, List<AtlasId> created)
			{
				Description = description;
				Before = before;
				Created = created;
			}
		}

		private const int UndoDepth = 20;

		private const float DuplicateOffsetMeters = 4f;

		private readonly PinStore _store;

		private readonly List<UndoRecord> _undo = new List<UndoRecord>();

		private readonly List<UndoRecord> _redo = new List<UndoRecord>();

		public int UndoCount => _undo.Count;

		public int RedoCount => _redo.Count;

		public PinOperations(PinStore store)
		{
			_store = store;
		}

		public bool Move(AtlasId id, RoadPoint newPosition)
		{
			return Apply("move", new AtlasId[1] { id }, delegate(AtlasPin pin)
			{
				pin.Position = newPosition;
			});
		}

		public AtlasPin? Duplicate(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasPin source) || source.Deleted)
			{
				return null;
			}
			AtlasPin atlasPin = _store.Create(delegate(AtlasPin pin)
			{
				DateTime createdUtc = pin.CreatedUtc;
				pin.CopyFrom(source);
				pin.Revision = 1L;
				pin.CreatedUtc = createdUtc;
				pin.ModifiedUtc = createdUtc;
				pin.Source = AtlasPinSource.Managed;
				pin.Deleted = false;
				pin.DeletedUtc = null;
				pin.Name = ((source.Name.Length == 0) ? "Copy" : (source.Name + " (copy)"));
				pin.Position = new RoadPoint(source.Position.X + 4f, source.Position.Y, source.Position.Z);
			});
			Push(new UndoRecord("duplicate", new List<AtlasPin>(), new List<AtlasId> { atlasPin.Id }));
			return atlasPin;
		}

		public bool SetArchived(AtlasId id, bool archived)
		{
			return Apply(archived ? "archive" : "unarchive", new AtlasId[1] { id }, delegate(AtlasPin pin)
			{
				pin.Archived = archived;
			});
		}

		public bool Delete(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasPin pin) || pin.Deleted)
			{
				return false;
			}
			Push(SnapshotRecord("delete", new AtlasId[1] { id }));
			return _store.Delete(id);
		}

		public bool RestoreDeleted(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasPin pin) || !pin.Deleted)
			{
				return false;
			}
			Push(SnapshotRecord("restore", new AtlasId[1] { id }));
			return _store.Restore(id);
		}

		public int BatchEdit(IReadOnlyList<AtlasId> ids, Action<AtlasPin> edit, string description = "batch edit")
		{
			List<AtlasId> list = new List<AtlasId>();
			foreach (AtlasId id in ids)
			{
				if (_store.TryGet(id, out AtlasPin pin) && !pin.Deleted)
				{
					list.Add(id);
				}
			}
			if (list.Count == 0)
			{
				return 0;
			}
			Push(SnapshotRecord(description, list));
			foreach (AtlasId item in list)
			{
				_store.Mutate(item, edit);
			}
			return list.Count;
		}

		public List<List<AtlasPin>> FindDuplicateGroups(float radiusMeters)
		{
			List<AtlasPin> list = new List<AtlasPin>(_store.Living);
			list.Sort((AtlasPin a, AtlasPin b) => a.CreatedUtc.CompareTo(b.CreatedUtc));
			float num = Math.Max(1f, radiusMeters);
			Dictionary<long, List<int>> dictionary = new Dictionary<long, List<int>>();
			for (int num2 = 0; num2 < list.Count; num2++)
			{
				long key = BucketKey(list[num2], num);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = new List<int>();
					dictionary.Add(key, value);
				}
				value.Add(num2);
			}
			bool[] array = new bool[list.Count];
			List<List<AtlasPin>> list2 = new List<List<AtlasPin>>();
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				if (array[num3])
				{
					continue;
				}
				List<AtlasPin> list3 = null;
				int num4 = (int)Math.Floor(list[num3].Position.X / num);
				int num5 = (int)Math.Floor(list[num3].Position.Z / num);
				for (int num6 = -1; num6 <= 1; num6++)
				{
					for (int num7 = -1; num7 <= 1; num7++)
					{
						if (!dictionary.TryGetValue(Combine(num4 + num6, num5 + num7), out var value2))
						{
							continue;
						}
						foreach (int item in value2)
						{
							if (item > num3 && !array[item] && AreLikelyDuplicates(list[num3], list[item], radiusMeters))
							{
								if (list3 == null)
								{
									list3 = new List<AtlasPin> { list[num3] };
								}
								list3.Add(list[item]);
								array[item] = true;
							}
						}
					}
				}
				if (list3 != null)
				{
					array[num3] = true;
					list2.Add(list3);
				}
			}
			return list2;
		}

		private static long BucketKey(AtlasPin pin, float cell)
		{
			return Combine((int)Math.Floor(pin.Position.X / cell), (int)Math.Floor(pin.Position.Z / cell));
		}

		private static long Combine(int cellX, int cellZ)
		{
			return (long)(((ulong)(uint)cellX << 32) ^ (uint)cellZ);
		}

		public bool Merge(AtlasId primaryId, IReadOnlyList<AtlasId> duplicateIds)
		{
			if (!_store.TryGet(primaryId, out AtlasPin pin) || pin.Deleted)
			{
				return false;
			}
			List<AtlasPin> duplicates = new List<AtlasPin>();
			foreach (AtlasId duplicateId in duplicateIds)
			{
				if (!duplicateId.Equals(primaryId) && _store.TryGet(duplicateId, out AtlasPin pin2) && !pin2.Deleted)
				{
					duplicates.Add(pin2);
				}
			}
			if (duplicates.Count == 0)
			{
				return false;
			}
			List<AtlasId> list = new List<AtlasId> { primaryId };
			foreach (AtlasPin item in duplicates)
			{
				list.Add(item.Id);
			}
			Push(SnapshotRecord("merge", list));
			_store.Mutate(primaryId, delegate(AtlasPin atlasPin)
			{
				foreach (AtlasPin item2 in duplicates)
				{
					foreach (string tag in item2.Tags)
					{
						if (!atlasPin.Tags.Contains(tag))
						{
							atlasPin.Tags.Add(tag);
						}
					}
					if (item2.Notes.Length > 0)
					{
						atlasPin.Notes = ((atlasPin.Notes.Length == 0) ? item2.Notes : (atlasPin.Notes + "\n" + item2.Notes));
					}
					atlasPin.Notes = ((atlasPin.Notes.Length == 0) ? $"[merged {item2.Id} \"{item2.Name}\"]" : (atlasPin.Notes + $"\n[merged {item2.Id} \"{item2.Name}\"]"));
					if (item2.CreatedUtc < atlasPin.CreatedUtc)
					{
						atlasPin.CreatedUtc = item2.CreatedUtc;
					}
				}
			});
			foreach (AtlasPin item3 in duplicates)
			{
				_store.Delete(item3.Id);
			}
			return true;
		}

		public bool Undo(out string summary)
		{
			return Rollback(_undo, _redo, "undo", out summary);
		}

		public bool Redo(out string summary)
		{
			return Rollback(_redo, _undo, "redo", out summary);
		}

		private bool Rollback(List<UndoRecord> from, List<UndoRecord> to, string verb, out string summary)
		{
			if (from.Count == 0)
			{
				summary = "Nothing to " + verb + ".";
				return false;
			}
			UndoRecord undoRecord = from[from.Count - 1];
			from.RemoveAt(from.Count - 1);
			List<AtlasId> list = new List<AtlasId>();
			foreach (AtlasPin item in undoRecord.Before)
			{
				list.Add(item.Id);
			}
			foreach (AtlasId item2 in undoRecord.Created)
			{
				list.Add(item2);
			}
			to.Add(SnapshotRecord(undoRecord.Description, list));
			Trim(to);
			foreach (AtlasId item3 in undoRecord.Created)
			{
				if (_store.TryGet(item3, out AtlasPin pin) && !pin.Deleted)
				{
					_store.Delete(item3);
				}
			}
			foreach (AtlasPin item4 in undoRecord.Before)
			{
				RestoreSnapshot(item4);
			}
			summary = $"{char.ToUpperInvariant(verb[0])}{verb.Substring(1)}: '{undoRecord.Description}' reverted ({undoRecord.Before.Count + undoRecord.Created.Count} pin(s)).";
			return true;
		}

		public List<AtlasPin> RecentlyDeleted(int limit = 10)
		{
			List<AtlasPin> list = new List<AtlasPin>(_store.Tombstones);
			list.Sort((AtlasPin a, AtlasPin b) => (b.DeletedUtc ?? DateTime.MinValue).CompareTo(a.DeletedUtc ?? DateTime.MinValue));
			if (list.Count > limit)
			{
				list.RemoveRange(limit, list.Count - limit);
			}
			return list;
		}

		private bool Apply(string description, IReadOnlyList<AtlasId> ids, Action<AtlasPin> edit)
		{
			List<AtlasId> list = new List<AtlasId>();
			foreach (AtlasId id in ids)
			{
				if (_store.TryGet(id, out AtlasPin pin) && !pin.Deleted)
				{
					list.Add(id);
				}
			}
			if (list.Count == 0)
			{
				return false;
			}
			Push(SnapshotRecord(description, list));
			foreach (AtlasId item in list)
			{
				_store.Mutate(item, edit);
			}
			return true;
		}

		private void RestoreSnapshot(AtlasPin snapshot)
		{
			_store.Mutate(snapshot.Id, delegate(AtlasPin pin)
			{
				long revision = pin.Revision;
				DateTime createdUtc = pin.CreatedUtc;
				pin.CopyFrom(snapshot);
				pin.Revision = revision;
				pin.CreatedUtc = createdUtc;
			});
		}

		private UndoRecord SnapshotRecord(string description, IReadOnlyList<AtlasId> ids)
		{
			List<AtlasPin> list = new List<AtlasPin>();
			foreach (AtlasId id in ids)
			{
				if (_store.TryGet(id, out AtlasPin pin))
				{
					list.Add(pin.Clone());
				}
			}
			return new UndoRecord(description, list, new List<AtlasId>());
		}

		private void Push(UndoRecord record)
		{
			_undo.Add(record);
			_redo.Clear();
			Trim(_undo);
		}

		private static void Trim(List<UndoRecord> stack)
		{
			while (stack.Count > 20)
			{
				stack.RemoveAt(0);
			}
		}

		private static bool AreLikelyDuplicates(AtlasPin a, AtlasPin b, float radiusMeters)
		{
			if (a.Position.HorizontalDistanceTo(b.Position) > radiusMeters)
			{
				return false;
			}
			if (string.Equals(a.IconId, b.IconId, StringComparison.Ordinal))
			{
				return true;
			}
			string text = a.Name.Trim().ToLowerInvariant();
			string text2 = b.Name.Trim().ToLowerInvariant();
			if (text.Length > 0)
			{
				return text == text2;
			}
			return false;
		}
	}
	internal sealed class PinQuery
	{
		private readonly List<string> _words = new List<string>();

		private readonly List<(string Field, string Value)> _tokens = new List<(string, string)>();

		private float _nearX;

		private float _nearZ;

		private float _nearRadius = -1f;

		public string Text { get; }

		public bool IsEmpty
		{
			get
			{
				if (_words.Count == 0 && _tokens.Count == 0)
				{
					return _nearRadius <= 0f;
				}
				return false;
			}
		}

		private PinQuery(string text)
		{
			Text = text;
		}

		public static PinQuery Parse(string? text)
		{
			PinQuery pinQuery = new PinQuery((text ?? "").Trim());
			string[] array = pinQuery.Text.Split(new char[1] { ' ' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				int num = text2.IndexOf(':');
				if (num > 0 && num < text2.Length - 1)
				{
					string text3 = text2.Substring(0, num).ToLowerInvariant();
					string text4 = text2.Substring(num + 1);
					if (text3 == "near")
					{
						string[] array2 = text4.Split(new char[1] { ',' });
						if (array2.Length == 3 && float.TryParse(array2[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array2[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) && result3 > 0f)
						{
							pinQuery._nearX = result;
							pinQuery._nearZ = result2;
							pinQuery._nearRadius = result3;
							continue;
						}
					}
					else if (IsKnownField(text3))
					{
						pinQuery._tokens.Add((text3, text4.ToLowerInvariant()));
						continue;
					}
				}
				pinQuery._words.Add(text2.ToLowerInvariant());
			}
			return pinQuery;
		}

		public bool Matches(AtlasPin pin)
		{
			if (_nearRadius > 0f && pin.Position.HorizontalDistanceTo(new RoadPoint(_nearX, 0f, _nearZ)) > _nearRadius)
			{
				return false;
			}
			foreach (var (field, value) in _tokens)
			{
				if (!MatchesToken(pin, field, value))
				{
					return false;
				}
			}
			foreach (string word in _words)
			{
				if (!MatchesWord(pin, word))
				{
					return false;
				}
			}
			return true;
		}

		public List<AtlasPin> Filter(IEnumerable<AtlasPin> pins)
		{
			List<AtlasPin> list = new List<AtlasPin>();
			foreach (AtlasPin pin in pins)
			{
				if (Matches(pin))
				{
					list.Add(pin);
				}
			}
			return list;
		}

		private static bool IsKnownField(string field)
		{
			switch (field)
			{
			case "icon":
			case "name":
			case "source":
			case "status":
			case "category":
			case "tag":
			case "scope":
			case "is":
				return true;
			default:
				return false;
			}
		}

		private static bool MatchesToken(AtlasPin pin, string field, string value)
		{
			switch (field)
			{
			case "name":
				return pin.Name.ToLowerInvariant().Contains(value);
			case "category":
				return pin.Category.ToLowerInvariant().Contains(value);
			case "icon":
				return pin.IconId.ToLowerInvariant().Contains(value);
			case "status":
				return pin.Status.ToString().ToLowerInvariant() == value;
			case "scope":
				return pin.Scope.ToString().ToLowerInvariant() == value;
			case "source":
				return pin.Source.ToString().ToLowerInvariant() == value;
			case "tag":
				foreach (string tag in pin.Tags)
				{
					if (tag.ToLowerInvariant().Contains(value))
					{
						return true;
					}
				}
				return false;
			case "is":
				return value switch
				{
					"checked" => pin.Checked, 
					"unchecked" => !pin.Checked, 
					"archived" => pin.Archived, 
					"deleted" => pin.Deleted, 
					_ => false, 
				};
			default:
				return false;
			}
		}

		private static bool MatchesWord(AtlasPin pin, string word)
		{
			if (pin.Name.ToLowerInvariant().Contains(word) || pin.Notes.ToLowerInvariant().Contains(word) || pin.Category.ToLowerInvariant().Contains(word))
			{
				return true;
			}
			foreach (string tag in pin.Tags)
			{
				if (tag.ToLowerInvariant().Contains(word))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class PinRenderingLedger<THandle> where THandle : class
	{
		public readonly struct RenderingState
		{
			public string Name { get; }

			public float X { get; }

			public float Y { get; }

			public float Z { get; }

			public int VanillaType { get; }

			public bool IsChecked { get; }

			public RenderingState(string name, float x, float y, float z, int vanillaType, bool isChecked)
			{
				Name = name;
				X = x;
				Y = y;
				Z = z;
				VanillaType = vanillaType;
				IsChecked = isChecked;
			}
		}

		public enum SyncDecision
		{
			None,
			Add,
			Remove,
			Replace,
			UpdateChecked
		}

		private const float ClaimToleranceSquaredMeters = 0.25f;

		private const float PositionEpsilonMeters = 0.01f;

		private readonly Func<THandle, RenderingState> _stateOf;

		private readonly Dictionary<THandle, AtlasId> _idByRendering = new Dictionary<THandle, AtlasId>();

		private readonly Dictionary<Guid, THandle> _renderingById = new Dictionary<Guid, THandle>();

		public int TrackedCount => _idByRendering.Count;

		public IEnumerable<KeyValuePair<THandle, AtlasId>> Tracked => _idByRendering;

		public PinRenderingLedger(Func<THandle, RenderingState> stateOf)
		{
			_stateOf = stateOf;
		}

		public void Reset()
		{
			_idByRendering.Clear();
			_renderingById.Clear();
		}

		public void Track(THandle rendering, AtlasId id)
		{
			_idByRendering[rendering] = id;
			_renderingById[id.Value] = rendering;
		}

		public void Untrack(THandle rendering)
		{
			if (_idByRendering.TryGetValue(rendering, out var value))
			{
				_idByRendering.Remove(rendering);
				_renderingById.Remove(value.Value);
			}
		}

		public bool IsTracked(THandle rendering)
		{
			return _idByRendering.ContainsKey(rendering);
		}

		public bool TryGetId(THandle rendering, out AtlasId id)
		{
			return _idByRendering.TryGetValue(rendering, out id);
		}

		public bool TryGetRendering(AtlasId id, out THandle rendering)
		{
			return _renderingById.TryGetValue(id.Value, out rendering);
		}

		public THandle? ClaimMatch(List<THandle> unclaimed, AtlasPin managed)
		{
			for (int i = 0; i < unclaimed.Count; i++)
			{
				RenderingState renderingState = _stateOf(unclaimed[i]);
				float num = renderingState.X - managed.Position.X;
				float num2 = renderingState.Z - managed.Position.Z;
				if (num * num + num2 * num2 <= 0.25f && string.Equals(renderingState.Name, managed.Name, StringComparison.Ordinal))
				{
					THandle result = unclaimed[i];
					unclaimed.RemoveAt(i);
					return result;
				}
			}
			return null;
		}

		public SyncDecision DecideSync(AtlasPin managed, int wantedVanillaType, out THandle? existing)
		{
			if (!_renderingById.TryGetValue(managed.Id.Value, out var value))
			{
				existing = null;
				if (!managed.Deleted && !managed.Archived)
				{
					return SyncDecision.Add;
				}
				return SyncDecision.None;
			}
			existing = value;
			if (managed.Deleted || managed.Archived)
			{
				return SyncDecision.Remove;
			}
			RenderingState renderingState = _stateOf(value);
			float num = renderingState.X - managed.Position.X;
			float num2 = renderingState.Y - managed.Position.Y;
			float num3 = renderingState.Z - managed.Position.Z;
			if (renderingState.VanillaType != wantedVanillaType || !string.Equals(renderingState.Name, managed.Name, StringComparison.Ordinal) || num * num + num2 * num2 + num3 * num3 > 0.0001f)
			{
				return SyncDecision.Replace;
			}
			if (renderingState.IsChecked == managed.Checked)
			{
				return SyncDecision.None;
			}
			return SyncDecision.UpdateChecked;
		}
	}
	internal sealed class PinStore
	{
		private readonly Dictionary<Guid, AtlasPin> _pins = new Dictionary<Guid, AtlasPin>();

		private readonly Func<DateTime> _clock;

		public bool IsDirty { get; private set; }

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

		public int Count => _pins.Count;

		public IEnumerable<AtlasPin> All => _pins.Values;

		public IEnumerable<AtlasPin> Living
		{
			get
			{
				foreach (AtlasPin value in _pins.Values)
				{
					if (!value.Deleted)
					{
						yield return value;
					}
				}
			}
		}

		public IEnumerable<AtlasPin> Tombstones
		{
			get
			{
				foreach (AtlasPin value in _pins.Values)
				{
					if (value.Deleted)
					{
						yield return value;
					}
				}
			}
		}

		public event Action<AtlasPin>? Changed;

		public PinStore(Func<DateTime>? clock = null)
		{
			_clock = clock ?? ((Func<DateTime>)(() => DateTime.UtcNow));
		}

		public PinStore(IEnumerable<AtlasPin> pins, Func<DateTime>? clock = null)
			: this(clock)
		{
			foreach (AtlasPin pin in pins)
			{
				_pins[pin.Id.Value] = pin;
			}
			IsDirty = false;
		}

		public bool TryGet(AtlasId id, out AtlasPin pin)
		{
			return _pins.TryGetValue(id.Value, out pin);
		}

		public AtlasPin Create(Action<AtlasPin>? initialize = null)
		{
			DateTime dateTime = _clock();
			AtlasPin atlasPin = new AtlasPin(AtlasId.NewPin())
			{
				Revision = 1L,
				CreatedUtc = dateTime,
				ModifiedUtc = dateTime,
				OwnerAuthor = LocalAuthor,
				LastAuthor = LocalAuthor
			};
			initialize?.Invoke(atlasPin);
			_pins[atlasPin.Id.Value] = atlasPin;
			Publish(atlasPin);
			return atlasPin;
		}

		public bool Mutate(AtlasId id, Action<AtlasPin> edit)
		{
			if (!_pins.TryGetValue(id.Value, out AtlasPin value))
			{
				return false;
			}
			edit(value);
			value.Revision++;
			value.ModifiedUtc = _clock();
			if (LocalAuthor.Length > 0)
			{
				value.LastAuthor = LocalAuthor;
			}
			Publish(value);
			return true;
		}

		public bool Delete(AtlasId id)
		{
			return Mutate(id, delegate(AtlasPin pin)
			{
				pin.Deleted = true;
				pin.DeletedUtc = _clock();
			});
		}

		public bool Restore(AtlasId id)
		{
			if (!_pins.TryGetValue(id.Value, out AtlasPin value) || !value.Deleted)
			{
				return false;
			}
			return Mutate(id, delegate(AtlasPin restored)
			{
				restored.Deleted = false;
				restored.DeletedUtc = null;
			});
		}

		public bool Upsert(AtlasPin incoming)
		{
			if (_pins.TryGetValue(incoming.Id.Value, out AtlasPin value))
			{
				if (incoming.Revision <= value.Revision)
				{
					return false;
				}
				value.CopyFrom(incoming);
				Publish(value);
				return true;
			}
			_pins[incoming.Id.Value] = incoming;
			Publish(incoming);
			return true;
		}

		public int PurgeTombstones(TimeSpan retention)
		{
			DateTime dateTime = _clock() - retention;
			List<Guid> list = new List<Guid>();
			foreach (AtlasPin value in _pins.Values)
			{
				if (!value.Deleted)
				{
					continue;
				}
				DateTime? deletedUtc = value.DeletedUtc;
				if (deletedUtc.HasValue)
				{
					DateTime valueOrDefault = deletedUtc.GetValueOrDefault();
					if (valueOrDefault < dateTime)
					{
						list.Add(value.Id.Value);
					}
				}
			}
			foreach (Guid item in list)
			{
				_pins.Remove(item);
			}
			if (list.Count > 0)
			{
				IsDirty = true;
			}
			return list.Count;
		}

		public void MarkClean()
		{
			IsDirty = false;
		}

		private void Publish(AtlasPin pin)
		{
			IsDirty = true;
			this.Changed?.Invoke(pin);
		}
	}
	internal static class PinTombstoneRule
	{
		public enum Verdict
		{
			Tombstone,
			KeepAndRebind
		}

		public static Verdict Decide(bool explicitVanillaDelete, bool sessionBound, bool alreadyDeleted)
		{
			if (explicitVanillaDelete && sessionBound && !alreadyDeleted)
			{
				return Verdict.Tombstone;
			}
			return Verdict.KeepAndRebind;
		}
	}
	internal sealed class PinWorkbenchController
	{
		public string NameField = "";

		public string IconField = "";

		public string CategoryField = "";

		public string ColorField = "";

		public string SizeField = "1";

		public string NotesField = "";

		public string TagsField = "";

		public AtlasPinStatus StatusField;

		public bool CheckedField;

		public AtlasScope ScopeField = AtlasScope.Private;

		public bool IsOpen { get; private set; }

		public AtlasId TargetId { get; private set; }

		public string InfoLine { get; private set; } = "";

		public void Open(AtlasPin pin)
		{
			TargetId = pin.Id;
			NameField = pin.Name;
			IconField = pin.IconId;
			CategoryField = pin.Category;
			int? colorArgb = pin.ColorArgb;
			object colorField;
			if (colorArgb.HasValue)
			{
				int valueOrDefault = colorArgb.GetValueOrDefault();
				colorField = (valueOrDefault & 0xFFFFFF).ToString("X6", CultureInfo.InvariantCulture);
			}
			else
			{
				colorField = "";
			}
			ColorField = (string)colorField;
			SizeField = pin.SizeScale.ToString("0.##", CultureInfo.InvariantCulture);
			NotesField = pin.Notes;
			TagsField = string.Join(", ", pin.Tags);
			StatusField = pin.Status;
			CheckedField = pin.Checked;
			ScopeField = pin.Scope;
			InfoLine = string.Format(CultureInfo.InvariantCulture, "{0} · ({1:0.#}, {2:0.#}) · created {3:yyyy-MM-dd} · edited {4:yyyy-MM-dd HH:mm} · rev {5}", pin.Source, pin.Position.X, pin.Position.Z, pin.CreatedUtc, pin.ModifiedUtc, pin.Revision);
			IsOpen = true;
		}

		public void Cancel()
		{
			IsOpen = false;
		}

		public AtlasPinStatus CycleStatus()
		{
			StatusField = ((StatusField != AtlasPinStatus.Warning) ? (StatusField + 1) : AtlasPinStatus.None);
			return StatusField;
		}

		public AtlasScope CycleScope()
		{
			ScopeField = ((ScopeField == AtlasScope.Server) ? AtlasScope.Private : (ScopeField + 1));
			return ScopeField;
		}

		public bool TryApply(PinOperations operations, out string message)
		{
			if (!IsOpen)
			{
				message = "The workbench is not open.";
				return false;
			}
			if (!TryParseColor(ColorField, out var colorArgb))
			{
				message = "Color must be empty, RRGGBB, or AARRGGBB hex.";
				return false;
			}
			if (!float.TryParse(SizeField.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				message = "Size must be a number between 0.5 and 2.";
				return false;
			}
			float clampedSize = Math.Max(0.5f, Math.Min(2f, result));
			string icon = IconField.Trim();
			IconRegistry.IconDefinition definition;
			bool flag = IconRegistry.TryResolve(icon, out definition);
			string name = NameField;
			string category = CategoryField.Trim();
			string notes = NotesField;
			List<string> tags = AtlasText.SplitTags(AtlasText.JoinTags(TagsField.Split(new char[1] { ',' })));
			AtlasPinStatus status = StatusField;
			bool isChecked = CheckedField;
			AtlasScope scope = ScopeField;
			if (operations.BatchEdit(new AtlasId[1] { TargetId }, delegate(AtlasPin pin)
			{
				pin.Name = name;
				pin.IconId = ((icon.Length == 0) ? "vanilla:dot" : icon);
				pin.Category = category;
				pin.ColorArgb = colorArgb;
				pin.SizeScale = clampedSize;
				pin.Notes = notes;
				pin.Tags.Clear();
				pin.Tags.AddRange(tags);
				pin.Status = status;
				pin.Checked = isChecked;
				pin.Scope = scope;
			}, "workbench edit") == 0)
			{
				message = "The pin no longer exists.";
				return false;
			}
			IsOpen = false;
			message = ((flag || icon.Length == 0) ? "Saved." : ("Saved. Icon '" + icon + "' is not in the registry; it renders as the fallback but the identity is preserved."));
			return true;
		}

		private static bool TryParseColor(string field, out int? colorArgb)
		{
			string text = field.Trim().TrimStart(new char[1] { '#' });
			if (text.Length == 0)
			{
				colorArgb = null;
				return true;
			}
			if ((text.Length == 6 || text.Length == 8) && uint.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				if (text.Length == 6)
				{
					result |= 0xFF000000u;
				}
				colorArgb = (int)result;
				return true;
			}
			colorArgb = null;
			return false;
		}
	}
	internal sealed class QuickPinInputGate
	{
		public enum FrameAction
		{
			None,
			Cancel,
			Capture
		}

		private bool _armed;

		private int _lastOwnedFrame = int.MinValue;

		public bool Armed => _armed;

		public void Arm(int frame)
		{
			_armed = true;
			_lastOwnedFrame = frame;
		}

		public FrameAction HandleFrame(int frame, bool cancelPressed, bool capturePressed)
		{
			if (!_armed)
			{
				return FrameAction.None;
			}
			_lastOwnedFrame = frame;
			if (cancelPressed)
			{
				_armed = false;
				return FrameAction.Cancel;
			}
			if (capturePressed)
			{
				_armed = false;
				return FrameAction.Capture;
			}
			return FrameAction.None;
		}

		public void Disarm()
		{
			_armed = false;
			_lastOwnedFrame = int.MinValue;
		}

		public bool SuppressAttack(int frame)
		{
			if (!_armed)
			{
				return frame == _lastOwnedFrame;
			}
			return true;
		}

		public bool SuppressMenu(int frame)
		{
			if (!_armed)
			{
				return frame == _lastOwnedFrame;
			}
			return true;
		}
	}
	internal static class QuickPinSuggester
	{
		public readonly struct Suggestion
		{
			public string Name { get; }

			public string IconId { get; }

			public string Category { get; }

			public Suggestion(string name, string iconId, string category)
			{
				Name = name;
				IconId = iconId;
				Category = category;
			}
		}

		private static readonly (string Keyword, string IconId, string Category)[] Rules = new(string, string, string)[35]
		{
			("portal", "vanilla:portal", "Travel"),
			("dock", "cc:harbor", "Travel"),
			("ship", "cc:harbor", "Travel"),
			("karve", "cc:harbor", "Travel"),
			("longship", "cc:harbor", "Travel"),
			("raft", "cc:harbor", "Travel"),
			("rock", "cc:resource", "Resources"),
			("ore", "cc:resource", "Resources"),
			("deposit", "cc:resource", "Resources"),
			("mine", "cc:resource", "Resources"),
			("copper", "cc:resource", "Resources"),
			("tin", "cc:resource", "Resources"),
			("silver", "cc:resource", "Resources"),
			("berr", "cc:resource", "Resources"),
			("mushroom", "cc:resource", "Resources"),
			("carrot", "cc:farm", "Base"),
			("turnip", "cc:farm", "Base"),
			("beehive", "cc:farm", "Base"),
			("crypt", "cc:danger", "Danger"),
			("cave", "cc:danger", "Danger"),
			("dungeon", "cc:danger", "Danger"),
			("spawner", "cc:danger", "Danger"),
			("nest", "cc:danger", "Danger"),
			("bonfire", "vanilla:fire", "Camp"),
			("fire", "vanilla:fire", "Camp"),
			("house", "vanilla:house", "Base"),
			("hut", "vanilla:house", "Base"),
			("tower", "vanilla:house", "Base"),
			("ruin", "vanilla:house", "Explore"),
			("rune", "vanilla:dot", "Explore"),
			("stone", "vanilla:dot", "Explore"),
			("workbench", "vanilla:hammer", "Work"),
			("forge", "vanilla:hammer", "Work"),
			("smelter", "vanilla:hammer", "Work"),
			("kiln", "vanilla:hammer", "Work")
		};

		public const string FallbackName = "Marked object";

		public static Suggestion Suggest(string? hoverName, string? prefabName)
		{
			return Suggest(hoverName, new string[1] { prefabName });
		}

		public static Suggestion Suggest(string? hoverName, IReadOnlyList<string?> objectNameCandidates)
		{
			string name = CleanName(hoverName, objectNameCandidates);
			StringBuilder stringBuilder = new StringBuilder((hoverName ?? "").ToLowerInvariant());
			foreach (string objectNameCandidate in objectNameCandidates)
			{
				stringBuilder.Append(' ').Append((objectNameCandidate ?? "").ToLowerInvariant());
			}
			string text = stringBuilder.ToString();
			(string, string, string)[] rules = Rules;
			for (int i = 0; i < rules.Length; i++)
			{
				var (value, iconId, category) = rules[i];
				if (text.Contains(value))
				{
					return new Suggestion(name, iconId, category);
				}
			}
			return new Suggestion(name, "vanilla:dot", "Explore");
		}

		public static string CleanName(string? hoverName, string? prefabName)
		{
			return CleanName(hoverName, new string[1] { prefabName });
		}

		public static string CleanName(string? hoverName, IReadOnlyList<string?> objectNameCandidates)
		{
			string text = StripMarkup(FirstLine(hoverName ?? "")).Trim();
			if (text.Length > 0 && !text.StartsWith("$", StringComparison.Ordinal))
			{
				return text;
			}
			foreach (string objectNameCandidate in objectNameCandidates)
			{
				string text2 = CleanObjectName(objectNameCandidate);
				if (text2.Length > 0 && !IsTechnicalName(text2))
				{
					string text3 = NameHumanizer.Humanize(text2);
					if (text3.Length > 0)
					{
						return text3;
					}
				}
			}
			return "Marked object";
		}

		public static bool IsTechnicalName(string? objectName)
		{
			string text = CleanObjectName(objectName).ToLowerInvariant();
			if (text.Length == 0)
			{
				return true;
			}
			string text2 = text.TrimEnd('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ' ');
			switch (text2)
			{
			case "collider":
			case "instance":
			case "cylinder":
			case "graphics":
			case "colliders":
			case "snappoint":
			case "collision":
			case "capsule":
			case "default":
			case "trigger":
			case "quad":
			case "root":
			case "cube":
			case "mesh":
			case "meshes":
			case "sphere":
			case "visual":
			case "attach":
			case "hitbox":
			case "clone":
			case "pivot":
			case "plane":
			case "model":
			case "gameobject":
			case "snap point":
			case "gfx":
			case "lod":
			case "new gameobject":
			case "new game object":
			case "attachpoint":
			case "attach point":
				return true;
			default:
				if (!text2.StartsWith("snappoint", StringComparison.Ordinal) && !text2.StartsWith("attachpoint", StringComparison.Ordinal))
				{
					return text2.StartsWith("lod ", StringComparison.Ordinal);
				}
				return true;
			}
		}

		public static string CleanObjectName(string? objectName)
		{
			string text = (objectName ?? "").Trim();
			bool flag = true;
			while (flag && text.Length > 0)
			{
				flag = false;
				if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(Array.Empty<char>());
					flag = true;
				}
				else if (text.EndsWith(")", StringComparison.Ordinal))
				{
					int num = text.LastIndexOf('(');
					if (num >= 0 && IsDigitsOrSpaces(text, num + 1, text.Length - 1))
					{
						text = text.Substring(0, num).TrimEnd(Array.Empty<char>());
						flag = true;
					}
				}
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			bool flag2 = false;
			string text2 = text;
			foreach (char c in text2)
			{
				char c2 = ((c == '_') ? ' ' : c);
				if (c2 == ' ')
				{
					flag2 = stringBuilder.Length > 0;
					continue;
				}
				if (flag2)
				{
					stringBuilder.Append(' ');
					flag2 = false;
				}
				stringBuilder.Append(c2);
			}
			return stringBuilder.ToString();
		}

		private static bool IsDigitsOrSpaces(string text, int start, int endExclusive)
		{
			bool result = false;
			for (int i = start; i < endExclusive; i++)
			{
				char c = text[i];
				if (char.IsDigit(c))
				{
					result = true;
				}
				else if (c != ' ')
				{
					return false;
				}
			}
			return result;
		}

		private static string FirstLine(string text)
		{
			int num = text.IndexOfAny(new char[2] { '\n', '\r' });
			if (num >= 0)
			{
				return text.Substring(0, num);
			}
			return text;
		}

		private static string StripMarkup(string text)
		{
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			bool flag = false;
			foreach (char c in text)
			{
				switch (c)
				{
				case '<':
					flag = true;
					continue;
				case '>':
					flag = false;
					continue;
				}
				if (!flag && c != '\n' && c != '\r')
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal static class RoadGraphRouter
	{
		private const float JunctionLinkMeters = 8f;

		public static List<RoadPoint>? FindPath(RoadAtlas roads, RoadPoint start, RoadPoint goal, float snapRadiusMeters, int maxExpandedNodes = 20000)
		{
			List<RoadPoint> list = new List<RoadPoint>();
			List<List<int>> list2 = new List<List<int>>();
			foreach (RoadStroke stroke in roads.Strokes)
			{
				int count = list.Count;
				for (int i = 0; i < stroke.Points.Count; i++)
				{
					list.Add(stroke.Points[i]);
					list2.Add(new List<int>());
					if (i > 0)
					{
						list2[count + i].Add(count + i - 1);
						list2[count + i - 1].Add(count + i);
					}
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			Dictionary<long, List<int>> dictionary = new Dictionary<long, List<int>>();
			for (int j = 0; j < list.Count; j++)
			{
				long key = CellKey(list[j]);
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = new List<int>();
					dictionary.Add(key, value);
				}
				value.Add(j);
			}
			for (int k = 0; k < list.Count; k++)
			{
				int num = (int)Math.Floor(list[k].X / 8f);
				int num2 = (int)Math.Floor(list[k].Z / 8f);
				for (int l = -1; l <= 1; l++)
				{
					for (int m = -1; m <= 1; m++)
					{
						if (!dictionary.TryGetValue(Combine(num + l, num2 + m), out var value2))
						{
							continue;
						}
						foreach (int item in value2)
						{
							if (item > k && list[k].HorizontalDistanceTo(list[item]) <= 8f && !list2[k].Contains(item))
							{
								list2[k].Add(item);
								list2[item].Add(k);
							}
						}
					}
				}
			}
			int num3 = Nearest(list, start, snapRadiusMeters);
			int num4 = Nearest(list, goal, snapRadiusMeters);
			if (num3 < 0 || num4 < 0)
			{
				return null;
			}
			SortedSet<(float, int)> sortedSet = new SortedSet<(float, int)>();
			Dictionary<int, float> dictionary2 = new Dictionary<int, float> { [num3] = 0f };
			Dictionary<int, int> dictionary3 = new Dictionary<int, int>();
			sortedSet.Add((list[num3].HorizontalDistanceTo(list[num4]), num3));
			int num5 = 0;
			while (sortedSet.Count > 0 && num5 < maxExpandedNodes)
			{
				int num6 = sortedSet.Min.Item2;
				sortedSet.Remove(sortedSet.Min);
				num5++;
				if (num6 == num4)
				{
					List<RoadPoint> list3 = new List<RoadPoint> { start };
					List<int> list4 = new List<int> { num6 };
					int value3;
					while (dictionary3.TryGetValue(num6, out value3))
					{
						list4.Add(value3);
						num6 = value3;
					}
					for (int num7 = list4.Count - 1; num7 >= 0; num7--)
					{
						list3.Add(list[list4[num7]]);
					}
					list3.Add(goal);
					return list3;
				}
				foreach (int item2 in list2[num6])
				{
					float num8 = dictionary2[num6] + list[num6].HorizontalDistanceTo(list[item2]);
					if (!dictionary2.TryGetValue(item2, out var value4) || num8 < value4)
					{
						dictionary2[item2] = num8;
						dictionary3[item2] = num6;
						sortedSet.Add((num8 + list[item2].HorizontalDistanceTo(list[num4]), item2));
					}
				}
			}
			return null;
		}

		private static int Nearest(List<RoadPoint> nodes, RoadPoint position, float maxRadius)
		{
			int result = -1;
			float num = maxRadius;
			for (int i = 0; i < nodes.Count; i++)
			{
				float num2 = nodes[i].HorizontalDistanceTo(in position);
				if (num2 <= num)
				{
					num = num2;
					result = i;
				}
			}
			return result;
		}

		private static long CellKey(RoadPoint point)
		{
			return Combine((int)Math.Floor(point.X / 8f), (int)Math.Floor(point.Z / 8f));
		}

		private static long Combine(int cellX, int cellZ)
		{
			return (long)(((ulong)(uint)cellX << 32) ^ (uint)cellZ);
		}
	}
	internal static class RouteCodec
	{
		public sealed class ParseResult
		{
			public List<AtlasRoute> Routes { get; }

			public int MalformedRows { get; }

			public int SupersededRows { get; }

			public ParseResult(List<AtlasRoute> routes, int malformedRows, int supersededRows)
			{
				Routes = routes;
				MalformedRows = malformedRows;
				SupersededRows = supersededRows;
			}
		}

		private sealed class Bucket
		{
			public long Revision { get; private set; }

			public AtlasRoute? Meta { get; set; }

			public List<(int Index, RoadPoint Point)> Points { get; } = new List<(int, RoadPoint)>();

			public void Reset(long revision)
			{
				Revision = revision;
				Meta = null;
				Points.Clear();
			}
		}

		public const string Header = "# ConcernedCartographer routes v2";

		private const string RowMarker = "1";

		private const string MetaMarkerV2 = "2";

		private const string MetaTag = "M";

		private const string PointTag = "P";

		private const int MetaFieldCountV1 = 17;

		private const int MetaFieldCountV2 = 19;

		public static IEnumerable<string> Serialize(IEnumerable<AtlasRoute> routes)
		{
			yield return "# ConcernedCartographer routes v2";
			foreach (AtlasRoute route in routes)
			{
				foreach (string item in SerializeRoute(route))
				{
					yield return item;
				}
			}
		}

		public static IEnumerable<string> SerializeRoute(AtlasRoute route)
		{
			string revision = route.Revision.ToString(CultureInfo.InvariantCulture);
			yield return string.Join("\t", route.Id.ToString(), revision, route.CreatedUtc.Ticks.ToString(CultureInfo.InvariantCulture), route.ModifiedUtc.Ticks.ToString(CultureInfo.InvariantCulture), "M", AtlasText.Escape(route.Name), ((int)route.Kind).ToString(CultureInfo.InvariantCulture), ((int)route.Style).ToString(CultureInfo.InvariantCulture), ((int)route.Status).ToString(CultureInfo.InvariantCulture), route.ColorArgb?.ToString(CultureInfo.InvariantCulture) ?? "", AtlasText.Escape(route.Notes), ((int)route.Scope).ToString(CultureInfo.InvariantCulture), route.Locked ? "1" : "0", route.Archived ? "1" : "0", route.Deleted ? "1" : "0", route.DeletedUtc?.Ticks.ToString(CultureInfo.InvariantCulture) ?? "", AtlasText.Escape(route.OwnerAuthor), AtlasText.Escape(route.LastAuthor), "2");
			for (int index = 0; index < route.Points.Count; index++)
			{
				RoadPoint roadPoint = route.Points[index];
				yield return string.Join("\t", route.Id.ToString(), revision, index.ToString(CultureInfo.InvariantCulture), roadPoint.X.ToString("R", CultureInfo.InvariantCulture), roadPoint.Y.ToString("R", CultureInfo.InvariantCulture), roadPoint.Z.ToString("R", CultureInfo.InvariantCulture), "P", "1");
			}
		}

		public static ParseResult Parse(IEnumerable<string> lines)
		{
			Dictionary<Guid, Bucket> dictionary = new Dictionary<Guid, Bucket>();
			List<Guid> list = new List<Guid>();
			int num = 0;
			int num2 = 0;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				string[] array = text.Split(new char[1] { '\t' });
				if (array.Length < 8 || (array[^1] != "1" && array[^1] != "2") || !AtlasId.TryParse(array[0], out var id) || !string.Equals(id.Kind, "route", StringComparison.Ordinal) || !long.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result < 1 || result > 1000000000000L)
				{
					num++;
					continue;
				}
				if (!dictionary.TryGetValue(id.Value, out var value))
				{
					value = new Bucket();
					dictionary.Add(id.Value, value);
					list.Add(id.Value);
				}
				if (result < value.Revision)
				{
					num2++;
					continue;
				}
				if (result > value.Revision)
				{
					if (value.Revision > 0)
					{
						num2++;
					}
					value.Reset(result);
				}
				if ((array.Length == 17 || array.Length == 19) && array[4] == "M")
				{
					if (!TryParseMeta(array, id, result, out AtlasRoute route))
					{
						num++;
					}
					else
					{
						value.Meta = route;
					}
				}
				else if (array.Length == 8 && array[6] == "P" && array[7] == "1")
				{
					if (!int.TryParse(array[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || result2 < 0 || !TryParseFloat(array[3], out var result3) || !TryParseFloat(array[4], out var result4) || !TryParseFloat(array[5], out var result5) || !AtlasLimits.IsFinite(result3) || !AtlasLimits.IsFinite(result4) || !AtlasLimits.IsFinite(result5))
					{
						num++;
					}
					else
					{
						value.Points.Add((result2, new RoadPoint(result3, result4, result5)));
					}
				}
				else
				{
					num++;
				}
			}
			List<AtlasRoute> list2 = new List<AtlasRoute>();
			foreach (Guid item2 in list)
			{
				Bucket bucket = dictionary[item2];
				if (bucket.Meta == null)
				{
					num++;
					continue;
				}
				bucket.Points.Sort(((int Index, RoadPoint Point) a, (int Index, RoadPoint Point) b) => a.Index.CompareTo(b.Index));
				foreach (var point in bucket.Points)
				{
					RoadPoint item = point.Point;
					bucket.Meta.Points.Add(item);
				}
				list2.Add(bucket.Meta);
			}
			return new ParseResult(list2, num, num2);
		}

		private static bool TryParseMeta(string[] parts, AtlasId id, long revision, out AtlasRoute route)
		{
			route = null;
			if (!long.TryParse(parts[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !long.TryParse(parts[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || !int.TryParse(parts[6], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3) || !Enum.IsDefined(typeof(RouteKind), result3) || !int.TryParse(parts[7], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4) || !Enum.IsDefined(typeof(RouteStyle), result4) || !int.TryParse(parts[8], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result5) || !Enum.IsDefined(typeof(RouteStatus), result5) || !TryParseNullableInt(parts[9], out var result6) || !int.TryParse(parts[11], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result7) || !Enum.IsDefined(typeof(AtlasScope), result7) || !TryParseFlag(parts[12], out var flag) || !TryParseFlag(parts[13], out var flag2) || !TryParseFlag(parts[14], out var flag3) || !TryParseNullableTicks(parts[15], out var result8))
			{
				return false;
			}
			bool flag4 = parts.Length == 19;
			route = new AtlasRoute(id)
			{
				Revision = revision,
				OwnerAuthor = (flag4 ? AtlasText.Unescape(parts[16]) : ""),
				LastAuthor = (flag4 ? AtlasText.Unescape(parts[17]) : ""),
				CreatedUtc = new DateTime(result, DateTimeKind.Utc),
				ModifiedUtc = new DateTime(result2, DateTimeKind.Utc),
				Name = AtlasLimits.Cap(AtlasText.Unescape(parts[5]), 200),
				Kind = (RouteKind)result3,
				Style = (RouteStyle)result4,
				Status = (RouteStatus)result5,
				ColorArgb = result6,
				Notes = AtlasLimits.Cap(AtlasText.Unescape(parts[10]), 10000),
				Scope = (AtlasScope)result7,
				Locked = flag,
				Archived = flag2,
				Deleted = flag3,
				DeletedUtc = result8
			};
			return true;
		}

		private static bool TryParseFlag(string value, out bool flag)
		{
			flag = value == "1";
			if (!(value == "1"))
			{
				return value == "0";
			}
			return true;
		}

		private static bool TryParseNullableInt(string value, out int? result)
		{
			if (value.Length == 0)
			{
				result = null;
				return true;
			}
			if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				result = result2;
				return true;
			}
			result = null;
			return false;
		}

		private static bool TryParseNullableTicks(string value, out DateTime? result)
		{
			if (value.Length == 0)
			{
				result = null;
				return true;
			}
			if (long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				result = new DateTime(result2, DateTimeKind.Utc);
				return true;
			}
			result = null;
			return false;
		}

		private static bool TryParseFloat(string value, out float result)
		{
			return float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out result);
		}
	}
	internal static class RouteEstimator
	{
		public readonly struct Estimate
		{
			public float DistanceMeters { get; }

			public float OnRoadFraction { get; }

			public float EstimatedMinutes { get; }

			public Estimate(float distanceMeters, float onRoadFraction, float estimatedMinutes)
			{
				DistanceMeters = distanceMeters;
				OnRoadFraction = onRoadFraction;
				EstimatedMinutes = estimatedMinutes;
			}
		}

		private const float SampleStepMeters = 5f;

		public static Estimate Compute(IReadOnlyList<RoadPoint> points, RoadAtlas roads, float onRoadToleranceMeters, float offRoadSpeedMetersPerSecond, float onRoadSpeedMetersPerSecond)
		{
			float num = 0f;
			float num2 = 0f;
			for (int i = 1; i < points.Count; i++)
			{
				RoadPoint roadPoint = points[i - 1];
				RoadPoint other = points[i];
				float num3 = roadPoint.HorizontalDistanceTo(in other);
				if (num3 <= 0f)
				{
					continue;
				}
				num += num3;
				int num4 = Math.Max(1, (int)(num3 / 5f));
				int num5 = 0;
				for (int j = 0; j < num4; j++)
				{
					float num6 = ((float)j + 0.5f) / (float)num4;
					RoadPoint position = new RoadPoint(roadPoint.X + (other.X - roadPoint.X) * num6, roadPoint.Y, roadPoint.Z + (other.Z - roadPoint.Z) * num6);
					if (roads.ContainsPointNear(RoadKind.Dirt, position, onRoadToleranceMeters) || roads.ContainsPointNear(RoadKind.Paved, position, onRoadToleranceMeters))
					{
						num5++;
					}
				}
				num2 += num3 * (float)num5 / (float)num4;
			}
			float onRoadFraction = ((num <= 0f) ? 0f : (num2 / num));
			float num7 = num - num2;
			float num8 = 0f;
			if (offRoadSpeedMetersPerSecond > 0f)
			{
				num8 += num7 / offRoadSpeedMetersPerSecond;
			}
			if (onRoadSpeedMetersPerSecond > 0f)
			{
				num8 += num2 / onRoadSpeedMetersPerSecond;
			}
			return new Estimate(num, onRoadFraction, num8 / 60f);
		}
	}
	internal sealed class RouteOperations
	{
		private sealed class UndoRecord
		{
			public string Description { get; }

			public List<AtlasRoute> Before { get; }

			public List<AtlasId> Created { get; }

			public UndoRecord(string description, List<AtlasRoute> before, List<AtlasId> created)
			{
				Description = description;
				Before = before;
				Created = created;
			}
		}

		private const int UndoDepth = 20;

		public const float FreehandMinimumSpacingMeters = 2f;

		private readonly RouteStore _store;

		private readonly List<UndoRecord> _undo = new List<UndoRecord>();

		private readonly List<UndoRecord> _redo = new List<UndoRecord>();

		public int UndoCount => _undo.Count;

		public int RedoCount => _redo.Count;

		public RouteOperations(RouteStore store)
		{
			_store = store;
		}

		public AtlasRoute StartRoute(RouteKind kind, string name)
		{
			AtlasRoute atlasRoute = _store.Create(delegate(AtlasRoute created)
			{
				created.Kind = kind;
				created.Name = name;
			});
			Push(new UndoRecord($"create {kind}", new List<AtlasRoute>(), new List<AtlasId> { atlasRoute.Id }));
			return atlasRoute;
		}

		public bool AppendPoint(AtlasId id, RoadPoint point)
		{
			if (!TryGetEditable(id, out AtlasRoute route))
			{
				return false;
			}
			if (route.Points.Count > 0 && route.Points[route.Points.Count - 1].HorizontalDistanceTo(in point) < 2f)
			{
				return false;
			}
			return _store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Points.Add(point);
			});
		}

		public int EraseNear(AtlasId id, RoadPoint center, float radiusMeters, out List<AtlasRoute> created)
		{
			created = new List<AtlasRoute>();
			if (radiusMeters <= 0f || !TryGetEditable(id, out AtlasRoute route))
			{
				return 0;
			}
			List<List<RoadPoint>> runs = new List<List<RoadPoint>>();
			List<RoadPoint> list = null;
			int num = 0;
			foreach (RoadPoint point in route.Points)
			{
				if (point.HorizontalDistanceTo(in center) <= radiusMeters)
				{
					num++;
					list = null;
					continue;
				}
				if (list == null)
				{
					list = new List<RoadPoint>();
					runs.Add(list);
				}
				list.Add(point);
			}
			if (num == 0)
			{
				return 0;
			}
			Push(SnapshotRecord("erase", new AtlasId[1] { id }));
			_store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Points.Clear();
				if (runs.Count > 0)
				{
					edited.Points.AddRange(runs[0]);
				}
			});
			if (runs.Count == 0)
			{
				_store.Delete(id);
			}
			for (int num2 = 1; num2 < runs.Count; num2++)
			{
				List<RoadPoint> run = runs[num2];
				AtlasRoute atlasRoute = _store.Create(delegate(AtlasRoute createdRoute)
				{
					CopyMetadata(route, createdRoute);
					createdRoute.Points.AddRange(run);
				});
				created.Add(atlasRoute);
				_undo[_undo.Count - 1].Created.Add(atlasRoute.Id);
			}
			return num;
		}

		public bool MoveWaypoint(AtlasId id, int index, RoadPoint position)
		{
			if (!TryGetEditable(id, out AtlasRoute route) || index < 0 || index >= route.Points.Count)
			{
				return false;
			}
			Push(SnapshotRecord("move waypoint", new AtlasId[1] { id }));
			return _store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Points[index] = position;
			});
		}

		public bool InsertWaypoint(AtlasId id, int afterIndex, RoadPoint position)
		{
			if (!TryGetEditable(id, out AtlasRoute route) || afterIndex < -1 || afterIndex >= route.Points.Count)
			{
				return false;
			}
			Push(SnapshotRecord("insert waypoint", new AtlasId[1] { id }));
			return _store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Points.Insert(afterIndex + 1, position);
			});
		}

		public bool RemoveWaypoint(AtlasId id, int index)
		{
			if (!TryGetEditable(id, out AtlasRoute route) || index < 0 || index >= route.Points.Count)
			{
				return false;
			}
			Push(SnapshotRecord("remove waypoint", new AtlasId[1] { id }));
			return _store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Points.RemoveAt(index);
			});
		}

		public AtlasRoute? Split(AtlasId id, int index)
		{
			if (!TryGetEditable(id, out AtlasRoute route) || index <= 0 || index >= route.Points.Count - 1)
			{
				return null;
			}
			Push(SnapshotRecord("split", new AtlasId[1] { id }));
			List<RoadPoint> tailPoints = route.Points.GetRange(index, route.Points.Count - index);
			_store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Points.RemoveRange(index + 1, edited.Points.Count - index - 1);
			});
			AtlasRoute atlasRoute = _store.Create(delegate(AtlasRoute created)
			{
				CopyMetadata(route, created);
				created.Points.AddRange(tailPoints);
			});
			_undo[_undo.Count - 1].Created.Add(atlasRoute.Id);
			return atlasRoute;
		}

		public bool Merge(AtlasId firstId, AtlasId secondId)
		{
			if (firstId.Equals(secondId) || !TryGetEditable(firstId, out AtlasRoute route) || !TryGetEditable(secondId, out AtlasRoute route2) || route.Points.Count == 0 || route2.Points.Count == 0)
			{
				return false;
			}
			Push(SnapshotRecord("merge", new AtlasId[2] { firstId, secondId }));
			RoadPoint other = route.Points[route.Points.Count - 1];
			bool num = route2.Points[route2.Points.Count - 1].HorizontalDistanceTo(in other) < route2.Points[0].HorizontalDistanceTo(in other);
			List<RoadPoint> appended = new List<RoadPoint>(route2.Points);
			if (num)
			{
				appended.Reverse();
			}
			_store.Mutate(firstId, delegate(AtlasRoute edited)
			{
				edited.Points.AddRange(appended);
			});
			_store.Delete(secondId);
			return true;
		}

		public bool SetLocked(AtlasId id, bool locked)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return false;
			}
			Push(SnapshotRecord(locked ? "lock" : "unlock", new AtlasId[1] { id }));
			return _store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Locked = locked;
			});
		}

		public bool SetArchived(AtlasId id, bool archived)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return false;
			}
			Push(SnapshotRecord(archived ? "archive" : "unarchive", new AtlasId[1] { id }));
			return _store.Mutate(id, delegate(AtlasRoute edited)
			{
				edited.Archived = archived;
			});
		}

		public bool EditMetadata(AtlasId id, Action<AtlasRoute> edit, string description = "edit")
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return false;
			}
			Push(SnapshotRecord(description, new AtlasId[1] { id }));
			return _store.Mutate(id, edit);
		}

		public bool Delete(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || route.Deleted)
			{
				return false;
			}
			Push(SnapshotRecord("delete", new AtlasId[1] { id }));
			return _store.Delete(id);
		}

		public bool RestoreDeleted(AtlasId id)
		{
			if (!_store.TryGet(id, out AtlasRoute route) || !route.Deleted)
			{
				return false;
			}
			Push(SnapshotRecord("restore", new AtlasId[1] { id }));
			return _store.Restore(id);
		}

		public bool Undo(out string summary)
		{
			return Rollback(_undo, _redo, "undo", out summary);
		}

		public bool Redo(out string summary)
		{
			return Rollback(_redo, _undo, "redo", out summary);
		}

		private bool Rollback(List<UndoRecord> from, List<UndoRecord> to, string verb, out string summary)
		{
			if (from.Count == 0)
			{
				summary = "Nothing to " + verb + ".";
				return false;
			}
			UndoRecord undoRecord = from[from.Count - 1];
			from.RemoveAt(from.Count - 1);
			List<AtlasId> list = new List<AtlasId>();
			foreach (AtlasRoute item in undoRecord.Before)
			{
				list.Add(item.Id);
			}
			list.AddRange(undoRecord.Created);
			to.Add(SnapshotRecord(undoRecord.Description, list));
			Trim(to);
			foreach (AtlasId item2 in undoRecord.Created)
			{
				if (_store.TryGet(item2, out AtlasRoute route) && !route.Deleted)
				{
					_store.Delete(item2);
				}
			}
			foreach (AtlasRoute before in undoRecord.Before)
			{
				_store.Mutate(before.Id, delegate(AtlasRoute atlasRoute)
				{
					long revision = atlasRoute.Revision;
					DateTime createdUtc = atlasRoute.CreatedUtc;
					atlasRoute.CopyFrom(before);
					atlasRoute.Revision = revision;
					atlasRoute.CreatedUtc = createdUtc;
				});
			}
			summary = $"{char.ToUpperInvariant(verb[0])}{verb.Substring(1)}: '{undoRecord.Description}' reverted.";
			return true;
		}

		private bool TryGetEditable(AtlasId id, out AtlasRoute route)
		{
			if (_store.TryGet(id, out route) && !route.Deleted)
			{
				return !route.Locked;
			}
			return false;
		}

		private static void CopyMetadata(AtlasRoute source, AtlasRoute target)
		{
			target.Name = ((source.Name.Length == 0) ? "" : (source.Name + " (part)"));
			target.Kind = source.Kind;
			target.Style = source.Style;
			target.Status = source.Status;
			target.ColorArgb = source.ColorArgb;
			target.Scope = source.Scope;
		}

		private UndoRecord SnapshotRecord(string description, IReadOnlyList<AtlasId> ids)
		{
			List<AtlasRoute> list = new List<AtlasRoute>();
			foreach (AtlasId id in ids)
			{
				if (_store.TryGet(id, out AtlasRoute route))
				{
					list.Add(route.Clone());
				}
			}
			return new UndoRecord(description, list, new List<AtlasId>());
		}

		private void Push(UndoRecord record)
		{
			_undo.Add(record);
			_redo.Clear();
			Trim(_undo);
		}

		private static void Trim(List<UndoRecord> stack)
		{
			while (stack.Count > 20)
			{
				stack.RemoveAt(0);
			}
		}
	}
	internal static class RoutePatternMath
	{
		public delegate void StampSegment(float startX, float startY, float endX, float endY);

		public delegate void StampDot(float x, float y);

		public static int WalkDashes(IReadOnlyList<(float X, float Y)> points, float dashOn, float dashOff, int maxStamps, StampSegment stamp)
		{
			float num = dashOn + dashOff;
			if (points == null || points.Count < 2 || stamp == null || !IsFinitePositive(dashOn) || !IsFinitePositive(num))
			{
				return 0;
			}
			int num2 = 0;
			float num3 = 0f;
			for (int i = 1; i < points.Count; i++)
			{
				(float X, float Y) tuple = points[i - 1];
				float item = tuple.X;
				float item2 = tuple.Y;
				(float X, float Y) tuple2 = points[i];
				float item3 = tuple2.X;
				float item4 = tuple2.Y;
				float num4 = item3 - item;
				float num5 = item4 - item2;
				float num6 = (float)Math.Sqrt(num4 * num4 + num5 * num5);
				if (!IsFinitePositive(num6) || num6 <= 1E-06f)
				{
					continue;
				}
				float num7 = num4 / num6;
				float num8 = num5 / num6;
				float num9 = 0f;
				while (num9 < num6 && num2 < maxStamps)
				{
					bool num10 = num3 < dashOn;
					float num11 = Math.Min(num10 ? (dashOn - num3) : (num - num3), num6 - num9);
					if (num10 && num11 > 0.0001f)
					{
						stamp(item + num7 * num9, item2 + num8 * num9, item + num7 * (num9 + num11), item2 + num8 * (num9 + num11));
						num2++;
					}
					float num12 = num9 + num11;
					if (!(num12 > num9))
					{
						break;
					}
					num9 = num12;
					num3 = (num3 + num11) % num;
				}
				if (num2 >= maxStamps)
				{
					break;
				}
			}
			return num2;
		}

		public static int WalkDots(IReadOnlyList<(float X, float Y)> points, float spacing, int maxStamps, StampDot stamp)
		{
			if (points == null || points.Count < 2 || stamp == null || !IsFinitePositive(spacing))
			{
				return 0;
			}
			int num = 0;
			float num2 = 0f;
			for (int i = 1; i < points.Count; i++)
			{
				if (num >= maxStamps)
				{
					break;
				}
				(float X, float Y) tuple = points[i - 1];
				float item = tuple.X;
				float item2 = tuple.Y;
				(float X, float Y) tuple2 = points[i];
				float item3 = tuple2.X;
				float item4 = tuple2.Y;
				float num3 = item3 - item;
				float num4 = item4 - item2;
				float num5 = (float)Math.Sqrt(num3 * num3 + num4 * num4);
				if (!IsFinitePositive(num5) || num5 <= 1E-06f)
				{
					continue;
				}
				if (num2 > num5)
				{
					num2 -= num5;
					continue;
				}
				float num6 = num3 / num5;
				float num7 = num4 / num5;
				int num8 = (int)Math.Min(Math.Floor((double)(num5 - num2) / (double)spacing) + 1.0, maxStamps - num);
				for (int j = 0; j < num8; j++)
				{
					float num9 = num2 + spacing * (float)j;
					stamp(item + num6 * num9, item2 + num7 * num9);
					num++;
				}
				num2 = num2 + spacing * (float)num8 - num5;
			}
			return num;
		}

		private static bool IsFinitePositive(float value)
		{
			if (value > 0f)
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	internal sealed class RouteStore
	{
		private readonly Dictionary<Guid, AtlasRoute> _routes = new Dictionary<Guid, AtlasRoute>();

		private readonly Func<DateTime> _clock;

		public bool IsDirty { get; private set; }

		public long ChangeStamp { get; private set; }

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

		public int Count => _routes.Count;

		public IEnumerable<AtlasRoute> All => _routes.Values;

		public IEnumerable<AtlasRoute> Living
		{
			get
			{
				foreach (AtlasRoute value in _routes.Values)
				{
					if (!value.Deleted)
					{
						yield return value;
					}
				}
			}
		}

		public event Action<AtlasRoute>? Changed;

		public RouteStore(Func<DateTime>? clock = null)
		{
			_clock = clock ?? ((Func<DateTime>)(() => DateTime.UtcNow));
		}

		public RouteStore(IEnumerable<AtlasRoute> routes, Func<DateTime>? clock = null)
			: this(clock)
		{
			foreach (AtlasRoute route in routes)
			{
				_routes[route.Id.Value] = route;
			}
			IsDirty = false;
		}

		public bool TryGet(AtlasId id, out AtlasRoute route)
		{
			return _routes.TryGetValue(id.Value, out route);
		}

		public AtlasRoute Create(Action<AtlasRoute>? initialize = null)
		{
			DateTime dateTime = _clock();
			AtlasRoute atlasRoute = new AtlasRoute(new AtlasId("route", Guid.NewGuid()))
			{
				Revision = 1L,
				CreatedUtc = dateTime,
				ModifiedUtc = dateTime,
				OwnerAuthor = LocalAuthor,
				LastAuthor = LocalAuthor
			};
			initialize?.Invoke(atlasRoute);
			_routes[atlasRoute.Id.Value] = atlasRoute;
			Publish(atlasRoute);
			return atlasRoute;
		}

		public bool Mutate(AtlasId id, Action<AtlasRoute> edit)
		{
			if (!_routes.TryGetValue(id.Value, out AtlasRoute value))
			{
				return false;
			}
			edit(value);
			value.Revision++;
			value.ModifiedUtc = _clock();
			if (LocalAuthor.Length > 0)
			{
				value.LastAuthor = LocalAuthor;
			}
			Publish(value);
			return true;
		}

		public bool Delete(AtlasId id)
		{
			return Mutate(id, delegate(AtlasRoute route)
			{
				route.Deleted = true;
				route.DeletedUtc = _clock();
			});
		}

		public bool Restore(AtlasId id)
		{
			if (!_routes.TryGetValue(id.Value, out AtlasRoute value) || !value.Deleted)
			{
				return false;
			}
			return Mutate(id, delegate(AtlasRoute restored)
			{
				restored.Deleted = false;
				restored.DeletedUtc = null;
			});
		}

		public bool Upsert(AtlasRoute incoming)
		{
			if (_routes.TryGetValue(incoming.Id.Value, out AtlasRoute value))
			{
				if (incoming.Revision <= value.Revision)
				{
					return false;
				}
				value.CopyFrom(incoming);
				Publish(value);
				return true;
			}
			_routes[incoming.Id.Value] = incoming;
			Publish(incoming);
			return true;
		}

		public void MarkClean()
		{
			IsDirty = false;
		}

		private void Publish(AtlasRoute route)
		{
			IsDirty = true;
			ChangeStamp++;
			this.Changed?.Invoke(route);
		}
	}
	internal sealed class SavedView
	{
		public string Name { get; }

		public string Query { get; }

		public bool ShowDirt { get; }

		public bool ShowPaved { get; }

		public bool ShowPins { get; }

		public bool ClusterEnabled { get; }

		public SavedView(string name, string query, bool showDirt, bool showPaved, bool showPins, bool clusterEnabled)
		{
			Name = name;
			Query = query;
			ShowDirt = showDirt;
			ShowPaved = showPaved;
			ShowPins = showPins;
			ClusterEnabled = clusterEnabled;
		}
	}
	internal sealed class SavedViewStore
	{
		public const string Header = "# ConcernedCartographer views v1";

		private const string RowMarker = "1";

		private const int FieldCount = 7;

		private readonly List<SavedView> _views = new List<SavedView>();

		public IReadOnlyList<SavedView> Views => _views;

		public bool IsDirty { get; private set; }

		public void Save(SavedView view)
		{
			for (int i = 0; i < _views.Count; i++)
			{
				if (string.Equals(_views[i].Name, view.Name, StringComparison.OrdinalIgnoreCase))
				{
					_views[i] = view;
					IsDirty = true;
					return;
				}
			}
			_views.Add(view);
			IsDirty = true;
		}

		public bool TryGet(string name, out SavedView view)
		{
			foreach (SavedView view2 in _views)
			{
				if (string.Equals(view2.Name, name, StringComparison.OrdinalIgnoreCase))
				{
					view = view2;
					return true;
				}
			}
			view = null;
			return false;
		}

		public bool Remove(string name)
		{
			for (int i = 0; i < _views.Count; i++)
			{
				if (string.Equals(_views[i].Name, name, StringComparison.OrdinalIgnoreCase))
				{
					_views.RemoveAt(i);
					IsDirty = true;
					return true;
				}
			}
			return false;
		}

		public void MarkClean()
		{
			IsDirty = false;
		}

		public IEnumerable<string> Serialize()
		{
			yield return "# ConcernedCartographer views v1";
			foreach (SavedView view in _views)
			{
				yield return string.Join("\t", AtlasText.Escape(view.Name), AtlasText.Escape(view.Query), view.ShowDirt ? "1" : "0", view.ShowPaved ? "1" : "0", view.ShowPins ? "1" : "0", view.ClusterEnabled ? "1" : "0", "1");
			}
		}

		public static SavedViewStore Parse(IEnumerable<string> lines, out int malformedRows)
		{
			SavedViewStore savedViewStore = new SavedViewStore();
			malformedRows = 0;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				string[] array = text.Split(new char[1] { '\t' });
				if (array.Length != 7 || array[6] != "1" || !TryFlag(array[2], out var flag) || !TryFlag(array[3], out var flag2) || !TryFlag(array[4], out var flag3) || !TryFlag(array[5], out var flag4))
				{
					malformedRows++;
					continue;
				}
				string text2 = AtlasText.Unescape(array[0]);
				if (text2.Length == 0)
				{
					malformedRows++;
				}
				else
				{
					savedViewStore.Save(new SavedView(text2, AtlasText.Unescape(array[1]), flag, flag2, flag3, flag4));
				}
			}
			savedViewStore.MarkClean();
			return savedViewStore;
		}

		private static bool TryFlag(string value, out bool flag)
		{
			flag = value == "1";
			if (!(value == "1"))
			{
				return value == "0";
			}
			return true;
		}
	}
	internal static class SpriteRebindRule
	{
		public static bool MustRebuild(string? wantedIconId, string? appliedIconId, bool appliedSpriteAlive)
		{
			if (!string.Equals(wantedIconId, appliedIconId, StringComparison.Ordinal))
			{
				return true;
			}
			if (wantedIconId != null)
			{
				return !appliedSpriteAlive;
			}
			return false;
		}
	}
	internal sealed class SurveyEngine
	{
		public sealed class Observation
		{
			public Guid Id { get; }

			public string PrefabName { get; }

			public string SuggestedName { get; }

			public string IconId { get; }

			public string Category { get; }

			public RoadPoint Position { get; }

			public DateTime SeenUtc { get; }

			public DateTime ExpiresUtc { get; }

			public Observation(Guid id, string prefabName, string suggestedName, string iconId, string category, RoadPoint position, DateTime seenUtc, DateTime expiresUtc)
			{
				Id = id;
				PrefabName = prefabName;
				SuggestedName = suggestedName;
				IconId = iconId;
				Category = category;
				Position = position;
				SeenUtc = seenUtc;
				ExpiresUtc = expiresUtc;
			}
		}

		public sealed class RejectedObservation
		{
			public string PrefabName { get; }

			public string SuggestedName { get; }

			public string IconId { get; }

			public string Category { get; }

			public RoadPoint Position { get; }

			public DateTime RejectedUtc { get; }

			public RejectedObservation(string prefabName, string suggestedName, string iconId, string category, RoadPoint position, DateTime rejectedUtc)
			{
				PrefabName = prefabName;
				SuggestedName = suggestedName;
				IconId = iconId;
				Category = category;
				Position = position;
				RejectedUtc = rejectedUtc;
			}
		}

		public enum OfferResult
		{
			Added,
			NoRule,
			Blacklisted,
			DuplicatePin,
			DuplicateObservation,
			DuplicateIdentity,
			RejectedEarlier,
			InsideBaseExclusion,
			CapReached
		}

		public const int MaxRejected = 500;

		private readonly List<Observation> _observations = new List<Observation>();

		private readonly List<RejectedObservation> _rejected = new List<RejectedObservation>();

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

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

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

		public SurveyRuleSet Rules { get; set; } = new SurveyRuleSet();

		public int MaxObservations { get; set; } = 200;

		public float BaseExclusionRadiusMeters { get; set; } = 30f;

		public IReadOnlyList<Observation> Observations => _observations;

		public IReadOnlyList<RejectedObservation> Rejected => _rejected;

		public bool RejectedDirty { get; private set; }

		public void MarkRejectedClean()
		{
			RejectedDirty = false;
		}

		public static string IdentityKey(string cleanedPrefabName, RoadPoint position)
		{
			return FormattableString.Invariant($"{cleanedPrefabName}|{(int)Math.Round(position.X)}|{(int)Math.Round(position.Z)}");
		}

		public OfferResult Offer(string prefabName, RoadPoint position, PinStore pins, DateTime nowUtc)
		{
			if (!Rules.TryMatch(prefabName, out SurveyRule match))
			{
				return OfferResult.NoRule;
			}
			string text = SurveyRuleSet.Clean(prefabName);
			string item = IdentityKey(text, position);
			if (_rejectedKeys.Contains(item))
			{
				return OfferResult.RejectedEarlier;
			}
			if (_pendingKeys.Contains(item) || _acceptedKeys.Contains(item))
			{
				return OfferResult.DuplicateIdentity;
			}
			if (_observations.Count >= MaxObservations)
			{
				return OfferResult.CapReached;
			}
			if (BaseExclusionRadiusMeters > 0f)
			{
				foreach (AtlasPin item2 in pins.Living)
				{
					if (IsBaseMarker(item2) && item2.Position.HorizontalDistanceTo(in position) <= BaseExclusionRadiusMeters)
					{
						return OfferResult.InsideBaseExclusion;
					}
				}
			}
			string text2 = HumanizedName(prefabName);
			if (match.DuplicateRadiusMeters > 0f)
			{
				foreach (AtlasPin item3 in pins.Living)
				{
					if (string.Equals(item3.Name, text2, StringComparison.OrdinalIgnoreCase) && item3.Position.HorizontalDistanceTo(in position) <= match.DuplicateRadiusMeters)
					{
						return OfferResult.DuplicatePin;
					}
				}
				foreach (Observation observation in _observations)
				{
					if (observation.PrefabName == text && observation.Position.HorizontalDistanceTo(in position) <= match.DuplicateRadiusMeters)
					{
						return OfferResult.DuplicateObservation;
					}
				}
			}
			DateTime expiresUtc = ((match.ExpiryMinutes > 0f) ? nowUtc.AddMinutes(match.ExpiryMinutes) : DateTime.MaxValue);
			_observations.Add(new Observation(Guid.NewGuid(), text, text2, match.IconId, match.Category, position, nowUtc, expiresUtc));
			_pendingKeys.Add(item);
			return OfferResult.Added;
		}

		private static string HumanizedName(string prefabName)
		{
			string text = NameHumanizer.Humanize(prefabName);
			if (text.Length <= 0)
			{
				return "Marked object";
			}
			return text;
		}

		public int Prune(DateTime nowUtc)
		{
			return _observations.RemoveAll(delegate(Observation observation)
			{
				if (observation.ExpiresUtc <= nowUtc)
				{
					_pendingKeys.Remove(IdentityKey(observation.PrefabName, observation.Position));
					return true;
				}
				return false;
			});
		}

		public bool Accept(Guid id, PinStore pins)
		{
			AtlasPin created;
			return Accept(id, pins, out created);
		}

		public bool Accept(Guid id, PinStore pins, out AtlasPin? created)
		{
			created = null;
			Observation observation = Find(id);
			if (observation == null)
			{
				return false;
			}
			created = CreatePin(pins, observation.SuggestedName, observation.IconId, observation.Category, observation.Position);
			string item = IdentityKey(observation.PrefabName, observation.Position);
			_pendingKeys.Remove(item);
			_acceptedKeys.Add(item);
			_observations.Remove(observation);
			return true;
		}

		public int AcceptAll(PinStore pins, Action<AtlasPin>? onCreated = null)
		{
			int num = 0;
			Observation[] array = _observations.ToArray();
			foreach (Observation observation in array)
			{
				if (Accept(observation.Id, pins, out AtlasPin created))
				{
					num++;
					if (created != null)
					{
						onCreated?.Invoke(created);
					}
				}
			}
			return num;
		}

		public bool Reject(Guid id, DateTime nowUtc)
		{
			Observation observation = Find(id);
			if (observation == null)
			{
				return false;
			}
			_observations.Remove(observation);
			_pendingKeys.Remove(IdentityKey(observation.PrefabName, observation.Position));
			AddRejected(new RejectedObservation(observation.PrefabName, observation.SuggestedName, observation.IconId, observation.Category, observation.Position, nowUtc));
			return true;
		}

		public int RejectAll(DateTime nowUtc)
		{
			int num = 0;
			Observation[] array = _observations.ToArray();
			foreach (Observation observation in array)
			{
				if (Reject(observation.Id, nowUtc))
				{
					num++;
				}
			}
			return num;
		}

		public bool RestoreRejected(int index, DateTime nowUtc)
		{
			if (index < 0 || index >= _rejected.Count || _observations.Count >= MaxObservations)
			{
				return false;
			}
			RejectedObservation rejectedObservation = _rejected[index];
			RemoveRejectedAt(index);
			_observations.Add(new Observation(Guid.NewGuid(), rejectedObservation.PrefabName, rejectedObservation.SuggestedName, rejectedObservation.IconId, rejectedObservation.Category, rejectedObservation.Position, nowUtc, DateTime.MaxValue));
			_pendingKeys.Add(IdentityKey(rejectedObservation.PrefabName, rejectedObservation.Position));
			return true;
		}

		public int RestoreAllRejected(DateTime nowUtc)
		{
			int num = 0;
			while (_rejected.Count > 0 && RestoreRejected(0, nowUtc))
			{
				num++;
			}
			return num;
		}

		public bool AcceptRejected(int index, PinStore pins)
		{
			AtlasPin created;
			return AcceptRejected(index, pins, out created);
		}

		public bool AcceptRejected(int index, PinStore pins, out AtlasPin? created)
		{
			created = null;
			if (index < 0 || index >= _rejected.Count)
			{
				return false;
			}
			RejectedObservation rejectedObservation = _rejected[index];
			RemoveRejectedAt(index);
			created = CreatePin(pins, rejectedObservation.SuggestedName, rejectedObservation.IconId, rejectedObservation.Category, rejectedObservation.Position);
			_acceptedKeys.Add(IdentityKey(rejectedObservation.PrefabName, rejectedObservation.Position));
			return true;
		}

		public int FindRejectedIndex(string identityKey)
		{
			for (int i = 0; i < _rejected.Count; i++)
			{
				if (string.Equals(IdentityKey(_rejected[i].PrefabName, _rejected[i].Position), identityKey, StringComparison.Ordinal))
				{
					return i;
				}
			}
			return -1;
		}

		public void LoadRejected(IEnumerable<RejectedObservation> entries)
		{
			_rejected.Clear();
			_rejectedKeys.Clear();
			foreach (RejectedObservation entry in entries)
			{
				if (_rejected.Count >= 500)
				{
					break;
				}
				_rejected.Add(entry);
				_rejectedKeys.Add(IdentityKey(entry.PrefabName, entry.Position));
			}
			RejectedDirty = false;
		}

		public void ResetSession()
		{
			_observations.Clear();
			_pendingKeys.Clear();
			_acceptedKeys.Clear();
		}

		private void AddRejected(RejectedObservation entry)
		{
			_rejected.Add(entry);
			_rejectedKeys.Add(IdentityKey(entry.PrefabName, entry.Position));
			while (_rejected.Count > 500)
			{
				RemoveRejectedAt(0);
			}
			RejectedDirty = true;
		}

		private void RemoveRejectedAt(int index)
		{
			RejectedObservation rejectedObservation = _rejected[index];
			_rejected.RemoveAt(index);
			_rejectedKeys.Remove(IdentityKey(rejectedObservation.PrefabName, rejectedObservation.Position));
			RejectedDirty = true;
		}

		private static AtlasPin CreatePin(PinStore pins, string name, string iconId, string category, RoadPoint position)
		{
			return pins.Create(delegate(AtlasPin pin)
			{
				pin.Name = name;
				pin.IconId = iconId;
				pin.Category = category;
				pin.Source = AtlasPinSource.Generated;
				pin.Tags.Add("surveyed");
				pin.Position = position;
			});
		}

		private Observation? Find(Guid id)
		{
			foreach (Observation observation in _observations)
			{
				if (observation.Id == id)
				{
					return observation;
				}
			}
			return null;
		}

		private static bool IsBaseMarker(AtlasPin pin)
		{
			if (string.Equals(pin.Category, "Base", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			foreach (string tag in pin.Tags)
			{
				if (string.Equals(tag, "base", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class SurveyRejectedCodec
	{
		public const string Header = "# ConcernedCartographer survey-rejected v1";

		private const string RowMarkerV1 = "1";

		public static IEnumerable<string> Serialize(IEnumerable<SurveyEngine.RejectedObservation> entries)
		{
			yield return "# ConcernedCartographer survey-rejected v1";
			foreach (SurveyEngine.RejectedObservation entry in entries)
			{
				yield return string.Join("\t", Flatten(entry.PrefabName), Flatten(entry.SuggestedName), Flatten(entry.IconId), Flatten(entry.Category), entry.Position.X.ToString("R", CultureInfo.InvariantCulture), entry.Position.Y.ToString("R", CultureInfo.InvariantCulture), entry.Position.Z.ToString("R", CultureInfo.InvariantCulture), entry.RejectedUtc.Ticks.ToString(CultureInfo.InvariantCulture), "1");
			}
		}

		public static List<SurveyEngine.RejectedObservation> Parse(IEnumerable<string> lines, out int malformedRows)
		{
			List<SurveyEngine.RejectedObservation> list = new List<SurveyEngine.RejectedObservation>();
			malformedRows = 0;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				string[] array = text.Split(new char[1] { '\t' });
				if (array.Length == 9 && array[0].Trim().Length != 0 && !(array[8] != "1") && TryParseFloat(array[4], out var result) && TryParseFloat(array[5], out var result2) && TryParseFloat(array[6], out var result3) && long.TryParse(array[7], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4) && result4 >= 0)
				{
					long num = result4;
					DateTime maxValue = DateTime.MaxValue;
					if (num <= maxValue.Ticks)
					{
						list.Add(new SurveyEngine.RejectedObservation(array[0], array[1], array[2], array[3], new RoadPoint(result, result2, result3), new DateTime(result4, DateTimeKind.Utc)));
						continue;
					}
				}
				malformedRows++;
			}
			return list;
		}

		private static string Flatten(string value)
		{
			return value.Replace('\t', ' ').Replace('\n', ' ').Replace('\r', ' ');
		}

		private static bool TryParseFloat(string value, out float result)
		{
			if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out result) && !float.IsNaN(result))
			{
				return !float.IsInfinity(result);
			}
			return false;
		}
	}
	internal sealed class SurveyRule
	{
		public string Pattern { get; }

		public string IconId { get; }

		public string Category { get; }

		public float DuplicateRadiusMeters { get; }

		public float ExpiryMinutes { get; }

		public bool Enabled { get; set; }

		public SurveyRule(string pattern, string iconId, string category, float duplicateRadiusMeters, float expiryMinutes, bool enabled = true)
		{
			Pattern = pattern;
			IconId = iconId;
			Category = category;
			DuplicateRadiusMeters = duplicateRadiusMeters;
			ExpiryMinutes = expiryMinutes;
			Enabled = enabled;
		}
	}
	internal sealed class SurveyRuleSet
	{
		public const string Header = "# ConcernedCartographer survey rules v1";

		private readonly List<SurveyRule> _rules = new List<SurveyRule>();

		private readonly List<string> _blacklist = new List<string>();

		public IReadOnlyList<SurveyRule> Rules => _rules;

		public IReadOnlyList<string> Blacklist => _blacklist;

		public void AddRule(SurveyRule rule)
		{
			_rules.Add(rule);
		}

		public SurveyRule? RemoveRuleAt(int index)
		{
			if (index < 0 || index >= _rules.Count)
			{
				return null;
			}
			SurveyRule result = _rules[index];
			_rules.RemoveAt(index);
			return result;
		}

		public SurveyRule? SetRuleEnabled(int index, bool enabled)
		{
			if (index < 0 || index >= _rules.Count)
			{
				return null;
			}
			_rules[index].Enabled = enabled;
			return _rules[index];
		}

		public void AddBlacklist(string pattern)
		{
			_blacklist.Add(pattern);
		}

		public bool TryMatch(string? prefabName, out SurveyRule match)
		{
			match = null;
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			string cleanedName = Clean(prefabName);
			foreach (string item in _blacklist)
			{
				if (PatternMatches(item, cleanedName))
				{
					return false;
				}
			}
			SurveyRule surveyRule = null;
			int num = -1;
			foreach (SurveyRule rule in _rules)
			{
				if (rule.Enabled && PatternMatches(rule.Pattern, cleanedName))
				{
					int num2 = (rule.Pattern.EndsWith("*", StringComparison.Ordinal) ? (rule.Pattern.Length - 1) : int.MaxValue);
					if (num2 > num)
					{
						num = num2;
						surveyRule = rule;
					}
				}
			}
			if (surveyRule == null)
			{
				return false;
			}
			match = surveyRule;
			return true;
		}

		public IEnumerable<string> Serialize()
		{
			yield return "# ConcernedCartographer survey rules v1";
			yield return "# pattern<TAB>icon<TAB>category<TAB>duplicate-radius-m<TAB>expiry-minutes ('pattern*' = prefix, '!pattern' = never pin; an optional 6th field 'off' disables a rule)";
			foreach (string item in _blacklist)
			{
				yield return "!" + item;
			}
			foreach (SurveyRule rule in _rules)
			{
				string text = string.Join("\t", rule.Pattern, rule.IconId, rule.Category, rule.DuplicateRadiusMeters.ToString("R", CultureInfo.InvariantCulture), rule.ExpiryMinutes.ToString("R", CultureInfo.InvariantCulture));
				yield return rule.Enabled ? text : (text + "\toff");
			}
		}

		public static SurveyRuleSet Parse(IEnumerable<string> lines, out int malformedRows)
		{
			SurveyRuleSet surveyRuleSet = new SurveyRuleSet();
			malformedRows = 0;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				if (text.StartsWith("!", StringComparison.Ordinal))
				{
					string text2 = Clean(text.Substring(1));
					if (text2.Length == 0)
					{
						malformedRows++;
					}
					else
					{
						surveyRuleSet.AddBlacklist(text2);
					}
					continue;
				}
				string[] array = text.Split(new char[1] { '\t' });
				if (array.Length < 5 || array.Length > 6 || array[0].Trim().Length == 0 || !float.TryParse(array[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || result < 0f || result > 500f || !float.TryParse(array[4], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || result2 < 0f || result2 > 1440f)
				{
					malformedRows++;
					continue;
				}
				bool enabled = true;
				if (array.Length == 6)
				{
					string text3 = array[5].Trim().ToLowerInvariant();
					if (text3 == "off")
					{
						enabled = false;
					}
					else if (text3 != "on" && text3.Length != 0)
					{
						malformedRows++;
						continue;
					}
				}
				surveyRuleSet.AddRule(new SurveyRule(Clean(array[0]), array[1].Trim(), array[2].Trim(), result, result2, enabled));
			}
			return surveyRuleSet;
		}

		public static SurveyRuleSet Default()
		{
			SurveyRuleSet surveyRuleSet = new SurveyRuleSet();
			surveyRuleSet.AddRule(new SurveyRule("raspberrybush*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("blueberrybush*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("cloudberrybush*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_mushroom*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_thistle*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_dandelion*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_flint*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_seedcarrot*", "cc:resource", "Resources", 40f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_seedturnip*", "cc:resource", "Resources", 40f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_seedonion*", "cc:resource", "Resources", 40f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("gucksack*", "cc:resource", "Resources", 40f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("beehive*", "cc:resource", "Resources", 60f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("rock4_copper*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("minerock_tin*", "cc:mine", "Resources", 30f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("silvervein*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("minerock_obsidian*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("mudpile*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("crypt*", "cc:dungeon", "Dungeons", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("sunkencrypt*", "cc:dungeon", "Dungeons", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("trollcave*", "cc:dungeon", "Dungeons", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("mountaincave*", "cc:dungeon", "Dungeons", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("runestone*", "cc:objective", "Points of interest", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("vegvisir*", "cc:objective", "Points of interest", 80f, 480f));
			surveyRuleSet.AddBlacklist("piece_*");
			surveyRuleSet.AddBlacklist("vfx_*");
			surveyRuleSet.AddBlacklist("sfx_*");
			surveyRuleSet.AddBlacklist("fx_*");
			return surveyRuleSet;
		}

		public static SurveyRuleSet Rc8StarterSet()
		{
			SurveyRuleSet surveyRuleSet = new SurveyRuleSet();
			surveyRuleSet.AddRule(new SurveyRule("raspberrybush*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("blueberrybush*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("cloudberrybush*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_mushroom*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("pickable_thistle*", "cc:resource", "Resources", 30f, 120f));
			surveyRuleSet.AddRule(new SurveyRule("rock4_copper*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("minerock_tin*", "cc:mine", "Resources", 30f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("silvervein*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("minerock_obsidian*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("mudpile*", "cc:mine", "Resources", 40f, 240f));
			surveyRuleSet.AddRule(new SurveyRule("crypt*", "cc:dungeon", "Dungeons", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("sunkencrypt*", "cc:dungeon", "Dungeons", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("trollcave*", "cc:dungeon", "Dungeons", 80f, 480f));
			surveyRuleSet.AddRule(new SurveyRule("vegvisir*", "cc:objective", "Points of interest", 80f, 480f));
			surveyRuleSet.AddBlacklist("piece_*");
			surveyRuleSet.AddBlacklist("vfx_*");
			surveyRuleSet.AddBlacklist("sfx_*");
			surveyRuleSet.AddBlacklist("fx_*");
			return surveyRuleSet;
		}

		public static SurveyRuleSet LegacyStarterSet()
		{
			SurveyRuleSet surveyRuleSet = new SurveyRuleSet();
			surveyRuleSet.AddRule(new SurveyRule("rock4_copper*", "cc:resource", "Resources", 40f, 60f));
			surveyRuleSet.AddRule(new SurveyRule("rock3_silver*", "cc:resource", "Resources", 40f, 60f));
			surveyRuleSet.AddRule(new SurveyRule("mudpile*", "cc:resource", "Resources", 40f, 60f));
			surveyRuleSet.AddRule(new SurveyRule("crypt*", "cc:danger", "Danger", 80f, 120f));
			surveyRuleSet.AddBlacklist("piece_*");
			return surveyRuleSet;
		}

		public static string Clean(string prefabName)
		{
			return prefabName.Replace("(Clone)", "").Trim().ToLowerInvariant();
		}

		private static bool PatternMatches(string pattern, string cleanedName)
		{
			string text = pattern.Trim().ToLowerInvariant();
			if (text.EndsWith("*", StringComparison.Ordinal))
			{
				return cleanedName.StartsWith(text.Substring(0, text.Length - 1), StringComparison.Ordinal);
			}
			return cleanedName == text;
		}
	}
	internal static class SyncPolicy
	{
		public enum Verdict
		{
			Apply,
			SupersededByLocal,
			NotShared,
			NonOwnerDeleteRejected,
			Conflict
		}

		public static Verdict EvaluatePin(AtlasPin? local, AtlasPin incoming)
		{
			return Evaluate(local?.Revision, local?.Deleted, local?.OwnerAuthor, (local == null) ? null : PinCodec.SerializeRow(local), incoming.Revision, incoming.Deleted, incoming.Scope, incoming.LastAuthor, PinCodec.SerializeRow(incoming));
		}

		public static Verdict EvaluateRoute(AtlasRoute? local, AtlasRoute incoming)
		{
			string localRow = null;
			if (local != null)
			{
				localRow = string.Join("\n", RouteCodec.SerializeRoute(local));
			}
			return Evaluate(local?.Revision, local?.Deleted, local?.OwnerAuthor, localRow, incoming.Revision, incoming.Deleted, incoming.Scope, incoming.LastAuthor, string.Join("\n", RouteCodec.SerializeRoute(incoming)));
		}

		private static Verdict Evaluate(long? localRevision, bool? localDeleted, string? localOwner, string? localRow, long incomingRevision, bool incomingDeleted, AtlasScope incomingScope, string incomingLastAuthor, string incomingRow)
		{
			if (incomingScope == AtlasScope.Private)
			{
				return Verdict.NotShared;
			}
			if (!localRevision.HasValue)
			{
				return Verdict.Apply;
			}
			if (incomingRevision < localRevision.Value)
			{
				return Verdict.SupersededByLocal;
			}
			if (incomingRevision == localRevision.Value)
			{
				if (!string.Equals(localRow, incomingRow, StringComparison.Ordinal))
				{
					return Verdict.Conflict;
				}
				return Verdict.SupersededByLocal;
			}
			if (incomingDeleted && localDeleted == false && !string.IsNullOrEmpty(localOwner) && !string.Equals(incomingLastAuthor, localOwner, StringComparison.Ordinal))
			{
				return Verdict.NonOwnerDeleteRejected;
			}
			return Verdict.Apply;
		}
	}
	internal sealed class SyncPlan
	{
		public List<AtlasPin> NewPins { get; } = new List<AtlasPin>();

		public List<AtlasPin> UpdatedPins { get; } = new List<AtlasPin>();

		public List<AtlasPin> TombstonePins { get; } = new List<AtlasPin>();

		public List<(AtlasPin Local, AtlasPin Remote)> PinConflicts { get; } = new List<(AtlasPin, AtlasPin)>();

		public int RejectedPins { get; set; }

		public int SupersededPins { get; set; }

		public List<AtlasRoute> NewRoutes { get; } = new List<AtlasRoute>();

		public List<AtlasRoute> UpdatedRoutes { get; } = new List<AtlasRoute>();

		public List<AtlasRoute> TombstoneRoutes { get; } = new List<AtlasRoute>();

		public List<(AtlasRoute Local, AtlasRoute Remote)> RouteConflicts { get; } = new List<(AtlasRoute, AtlasRoute)>();

		public int RejectedRoutes { get; set; }

		public int SupersededRoutes { get; set; }

		public bool IsEmpty
		{
			get
			{
				if (NewPins.Count == 0 && UpdatedPins.Count == 0 && TombstonePins.Count == 0 && PinConflicts.Count == 0 && NewRoutes.Count == 0 && UpdatedRoutes.Count == 0 && TombstoneRoutes.Count == 0)
				{
					return RouteConflicts.Count == 0;
				}
				return false;
			}
		}

		public string Summary()
		{
			return $"pins: +{NewPins.Count} new, {UpdatedPins.Count} updated, {TombstonePins.Count} deletions, " + $"{PinConflicts.Count} conflicts, {RejectedPins} rejected, {SupersededPins} already-newer · " + $"routes: +{NewRoutes.Count} new, {UpdatedRoutes.Count} updated, {TombstoneRoutes.Count} deletions, " + $"{RouteConflicts.Count} conflicts, {RejectedRoutes} rejected, {SupersededRoutes} already-newer";
		}

		public List<string> DeletionNames(int max)
		{
			List<string> list = new List<string>();
			foreach (AtlasPin tombstonePin in TombstonePins)
			{
				if (list.Count >= max)
				{
					return list;
				}
				list.Add("pin \"" + ((tombstonePin.Name.Length > 0) ? tombstonePin.Name : tombstonePin.Id.ToString()) + "\"");
			}
			foreach (AtlasRoute tombstoneRoute in TombstoneRoutes)
			{
				if (list.Count >= max)
				{
					return list;
				}
				list.Add("route \"" + ((tombstoneRoute.Name.Length > 0) ? tombstoneRoute.Name : tombstoneRoute.Id.ToString()) + "\"");
			}
			return list;
		}
	}
	internal static class SyncPlanner
	{
		public static (List<AtlasPin> Pins, List<AtlasRoute> Routes) CollectShared(PinStore pins, RouteStore routes)
		{
			List<AtlasPin> list = new List<AtlasPin>();
			foreach (AtlasPin item in pins.All)
			{
				if (item.Scope != AtlasScope.Private)
				{
					list.Add(item.Clone());
				}
			}
			List<AtlasRoute> list2 = new List<AtlasRoute>();
			foreach (AtlasRoute item2 in routes.All)
			{
				if (item2.Scope != AtlasScope.Private)
				{
					list2.Add(item2.Clone());
				}
			}
			return (Pins: list, Routes: list2);
		}

		public static SyncPlan Plan(PinStore pins, RouteStore routes, IReadOnlyList<AtlasPin> remotePins, IReadOnlyList<AtlasRoute> remoteRoutes)
		{
			SyncPlan syncPlan = new SyncPlan();
			foreach (AtlasPin remotePin in remotePins)
			{
				pins.TryGet(remotePin.Id, out AtlasPin pin);
				switch (SyncPolicy.EvaluatePin(pin, remotePin))
				{
				case SyncPolicy.Verdict.Apply:
					if (pin == null)
					{
						syncPlan.NewPins.Add(remotePin);
					}
					else if (remotePin.Deleted && !pin.Deleted)
					{
						syncPlan.TombstonePins.Add(remotePin);
					}
					else
					{
						syncPlan.UpdatedPins.Add(remotePin);
					}
					break;
				case SyncPolicy.Verdict.Conflict:
					syncPlan.PinConflicts.Add((pin, remotePin));
					break;
				case SyncPolicy.Verdict.NonOwnerDeleteRejected:
					syncPlan.RejectedPins++;
					break;
				case SyncPolicy.Verdict.SupersededByLocal:
					syncPlan.SupersededPins++;
					break;
				case SyncPolicy.Verdict.NotShared:
					syncPlan.RejectedPins++;
					break;
				}
			}
			foreach (AtlasRoute remoteRoute in remoteRoutes)
			{
				routes.TryGet(remoteRoute.Id, out AtlasRoute route);
				switch (SyncPolicy.EvaluateRoute(route, remoteRoute))
				{
				case SyncPolicy.Verdict.Apply:
					if (route == null)
					{
						syncPlan.NewRoutes.Add(remoteRoute);
					}
					else if (remoteRoute.Deleted && !route.Deleted)
					{
						syncPlan.TombstoneRoutes.Add(remoteRoute);
					}
					else
					{
						syncPlan.UpdatedRoutes.Add(remoteRoute);
					}
					break;
				case SyncPolicy.Verdict.Conflict:
					syncPlan.RouteConflicts.Add((route, remoteRoute));
					break;
				case SyncPolicy.Verdict.NonOwnerDeleteRejected:
					syncPlan.RejectedRoutes++;
					break;
				case SyncPolicy.Verdict.SupersededByLocal:
					syncPlan.SupersededRoutes++;
					break;
				case SyncPolicy.Verdict.NotShared:
					syncPlan.RejectedRoutes++;
					break;
				}
			}
			return syncPlan;
		}

		public static int Apply(SyncPlan plan, PinStore pins, RouteStore routes, bool takeRemoteOnConflict)
		{
			int num = 0;
			foreach (AtlasPin newPin in plan.NewPins)
			{
				num += (pins.Upsert(newPin.Clone()) ? 1 : 0);
			}
			foreach (AtlasPin updatedPin in plan.UpdatedPins)
			{
				num += (pins.Upsert(updatedPin.Clone()) ? 1 : 0);
			}
			foreach (AtlasPin tombstonePin in plan.TombstonePins)
			{
				num += (pins.Upsert(tombstonePin.Clone()) ? 1 : 0);
			}
			foreach (var (atlasPin, atlasPin2) in plan.PinConflicts)
			{
				if (takeRemoteOnConflict)
				{
					AtlasPin captured = atlasPin2;
					pins.Mutate(atlasPin.Id, delegate(AtlasPin pin)
					{
						long revision = pin.Revision;
						DateTime createdUtc = pin.CreatedUtc;
						pin.CopyFrom(captured);
						pin.Revision = revision;
						pin.CreatedUtc = createdUtc;
					});
					num++;
				}
			}
			foreach (AtlasRoute newRoute in plan.NewRoutes)
			{
				num += (routes.Upsert(newRoute.Clone()) ? 1 : 0);
			}
			foreach (AtlasRoute updatedRoute in plan.UpdatedRoutes)
			{
				num += (routes.Upsert(updatedRoute.Clone()) ? 1 : 0);
			}
			foreach (AtlasRoute tombstoneRoute in plan.TombstoneRoutes)
			{
				num += (routes.Upsert(tombstoneRoute.Clone()) ? 1 : 0);
			}
			foreach (var (atlasRoute, atlasRoute2) in plan.RouteConflicts)
			{
				if (takeRemoteOnConflict)
				{
					AtlasRoute captured2 = atlasRoute2;
					routes.Mutate(atlasRoute.Id, delegate(AtlasRoute route)
					{
						long revision = route.Revision;
						DateTime createdUtc = route.CreatedUtc;
						route.CopyFrom(captured2);
						route.Revision = revision;
						route.CreatedUtc = createdUtc;
					});
					num++;
				}
			}
			return num;
		}
	}
	internal sealed class SyncInbox
	{
		public sealed class Envelope
		{
			public string AuthorId { get; }

			public string AuthorName { get; }

			public List<AtlasPin> Pins { get; }

			public List<AtlasRoute> Routes { get; }

			public DateTime ReceivedUtc { get; }

			public Envelope(string authorId, string authorName, List<AtlasPin> pins, List<AtlasRoute> routes, DateTime receivedUtc)
			{
				AuthorId = authorId;
				AuthorName = authorName;
				Pins = pins;
				Routes = routes;
				ReceivedUtc = receivedUtc;
			}
		}

		public const int MaxAuthors = 8;

		private readonly List<Envelope> _envelopes = new List<Envelope>();

		public IReadOnlyList<Envelope> Envelopes => _envelopes;

		public void Add(Envelope envelope)
		{
			_envelopes.RemoveAll((Envelope existing) => existing.AuthorId == envelope.AuthorId);
			_envelopes.Add(envelope);
			while (_envelopes.Count > 8)
			{
				_envelopes.RemoveAt(0);
			}
		}

		public bool TryPeek(string authorIdOrName, out Envelope envelope)
		{
			foreach (Envelope envelope2 in _envelopes)
			{
				if (string.Equals(envelope2.AuthorId, authorIdOrName, StringComparison.OrdinalIgnoreCase) || string.Equals(envelope2.AuthorName, authorIdOrName, StringComparison.OrdinalIgnoreCase))
				{
					envelope = envelope2;
					return true;
				}
			}
			envelope = null;
			return false;
		}

		public bool TryTake(string authorIdOrName, out Envelope envelope)
		{
			foreach (Envelope envelope2 in _envelopes)
			{
				if (string.Equals(envelope2.AuthorId, authorIdOrName, StringComparison.OrdinalIgnoreCase) || string.Equals(envelope2.AuthorName, authorIdOrName, StringComparison.OrdinalIgnoreCase))
				{
					envelope = envelope2;
					_envelopes.Remove(envelope2);
					return true;
				}
			}
			envelope = null;
			return false;
		}

		public void Clear()
		{
			_envelopes.Clear();
		}
	}
}
namespace TheConcernedCat.ConcernedCartographer.Roads
{
	internal static class AlignmentVerdicts
	{
		public const float ObservationPassMeters = 3f;

		public const float ProjectionPassTexels = 1f;

		public const float MarkerPassPixels = 2f;

		public const float QuantizationVisiblePixelsPerTexel = 4f;

		public static string Evaluate(bool standingOnRoad, bool hasNearestRoadPoint, float nearestRoadDistanceMeters, bool hasProjectionDelta, float projectionDeltaTexels, float screenPixelsPerTexel, bool vectorLayerActive, bool hasMarkerDelta, float markerDeltaPixels)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (!standingOnRoad)
			{
				stringBuilder.Append("A observation: N/A — no road paint classified under the player.");
			}
			else if (!hasNearestRoadPoint)
			{
				stringBuilder.Append("A observation: NO DATA — road paint under the player but no stored road point nearby. Only ground you explicitly Pathen/Paved is recorded (v1 rule); native or walked-on paint is never a road.");
			}
			else if (nearestRoadDistanceMeters <= 3f)
			{
				stringBuilder.Append(Invariant($"A observation: PASS — nearest stored road point {nearestRoadDistanceMeters:0.00} m from the player (≤ {3f:0.0} m)."));
			}
			else
			{
				stringBuilder.Append(Invariant($"A observation: FAIL — nearest stored road point is {nearestRoadDistanceMeters:0.00} m away; stored geometry does not match the player position."));
			}
			stringBuilder.Append('\n');
			if (!hasProjectionDelta)
			{
				stringBuilder.Append("B projection: N/A — native pixel projection unavailable.");
			}
			else if (projectionDeltaTexels <= 1f)
			{
				stringBuilder.Append(Invariant($"B projection: PASS — native vs CC projection differ by {projectionDeltaTexels:0.00} texels (≤ {1f:0.0})."));
			}
			else
			{
				stringBuilder.Append(Invariant($"B projection: FAIL — native vs CC projection differ by {projectionDeltaTexels:0.00} texels; projections diverge."));
			}
			stringBuilder.Append('\n');
			if (screenPixelsPerTexel <= 4f)
			{
				stringBuilder.Append(Invariant($"C render resolution: PASS — one texel spans {screenPixelsPerTexel:0.0} px at this zoom; texture quantization is not visually significant."));
			}
			else if (vectorLayerActive)
			{
				stringBuilder.Append(Invariant($"C render resolution: PASS — one texel spans {screenPixelsPerTexel:0.0} px, but the high-precision vector layer is ACTIVE (sub-texel road ink)."));
			}
			else
			{
				stringBuilder.Append(Invariant($"C render resolution: FAIL — one texel spans {screenPixelsPerTexel:0.0} px at this zoom and the vector layer is INACTIVE: texture road ink visibly snaps up to ±half a texel (enable Map/HighPrecisionLargeMapRoads)."));
			}
			stringBuilder.Append('\n');
			if (!hasMarkerDelta)
			{
				stringBuilder.Append("D marker anchor: N/A — live player marker not available (large map closed?).");
			}
			else if (markerDeltaPixels <= 2f)
			{
				stringBuilder.Append(Invariant($"D marker anchor: PASS — live player marker sits {markerDeltaPixels:0.00} px from the canonical projection (≤ {2f:0.0} px)."));
			}
			else
			{
				stringBuilder.Append(Invariant($"D marker anchor: FAIL — live player marker is {markerDeltaPixels:0.00} px from the canonical projection; the marker anchor itself is offset."));
			}
			string text = BuildGuidance(standingOnRoad, hasMarkerDelta);
			if (text.Length > 0)
			{
				stringBuilder.Append('\n').Append(text);
			}
			return stringBuilder.ToString();
		}

		public static string BuildGuidance(bool standingOnRoad, bool markerAvailable)
		{
			if (standingOnRoad && markerAvailable)
			{
				return "";
			}
			if (!standingOnRoad && !markerAvailable)
			{
				return "For the full A/B/C/D check: OPEN THE LARGE MAP and STAND ON a road you explicitly built (Pathen or Paved), then run 'cc_roads align live' again.";
			}
			if (!standingOnRoad)
			{
				return "For the full A/B/C/D check: STAND ON a road you explicitly built (Pathen or Paved) — only explicit player construction is recorded — then run 'cc_roads align live' again.";
			}
			return "For the full A/B/C/D check: OPEN THE LARGE MAP (D needs the live player marker), then run 'cc_roads align live' again.";
		}

		private static string Invariant(FormattableString text)
		{
			return text.ToString(CultureInfo.InvariantCulture);
		}
	}
	internal static class RecoveryShapeHeuristic
	{
		public const int WindowRadius = 2;

		public const float MaximumPaintedFraction = 0.5f;

		public static bool IsPathLike(Func<int, int, bool> isRoadPainted, int x, int y)
		{
			int num = 5 * 5;
			int num2 = 0;
			for (int i = -2; i <= 2; i++)
			{
				for (int j = -2; j <= 2; j++)
				{
					if (isRoadPainted(x + j, y + i))
					{
						num2++;
					}
				}
			}
			return num2 <= (int)((float)num * 0.5f);
		}
	}
	internal sealed class RoadAtlas
	{
		public readonly struct MigrationResult
		{
			public int RemovedStrokes { get; }

			public int RemovedPoints { get; }

			public MigrationResult(int removedStrokes, int removedPoints)
			{
				RemovedStrokes = removedStrokes;
				RemovedPoints = removedPoints;
			}
		}

		public readonly struct MaintenanceResult
		{
			public int MergedStrokes { get; }

			public int RemovedPoints { get; }

			public MaintenanceResult(int mergedStrokes, int removedPoints)
			{
				MergedStrokes = mergedStrokes;
				RemovedPoints = removedPoints;
			}
		}

		private readonly struct GridEntry
		{
			public RoadStroke Stroke { get; }

			public int SegmentIndex { get; }

			public GridEntry(RoadStroke stroke, int segmentIndex)
			{
				Stroke = stroke;
				SegmentIndex = segmentIndex;
			}
		}

		private const float GridCellMeters = 4f;

		private const int ActiveTailExemptPoints = 3;

		public const float SimplifyToleranceMeters = 1f;

		public const float JoinToleranceMeters = 2.5f;

		private readonly Dictionary<long, List<GridEntry>> _grid = new Dictionary<long, List<GridEntry>>();

		private readonly Dictionary<RoadObservationSource, RoadStroke> _activeStrokes = new Dictionary<RoadObservationSource, RoadStroke>();

		public List<RoadStroke> Strokes { get; } = new List<RoadStroke>();

		public bool IsDirty { get; private set; }

		public int PointCount
		{
			get
			{
				int num = 0;
				foreach (RoadStroke stroke in Strokes)
				{
					num += stroke.Points.Count;
				}
				return num;
			}
		}

		public RoadAtlas()
		{
		}

		public RoadAtlas(IEnumerable<RoadStroke> strokes)
		{
			foreach (RoadStroke stroke in strokes)
			{
				if (stroke.Points.Count != 0)
				{
					Strokes.Add(stroke);
					IndexStroke(stroke);
				}
			}
			IsDirty = false;
		}

		public bool RecordSample(RoadObservationSource source, RoadKind kind, RoadPoint position, RoadSamplingRules rules, out RoadSegment segment)
		{
			segment = default(RoadSegment);
			_activeStrokes.TryGetValue(source, out RoadStroke value);
			if (IsSuppressedDuplicate(value, kind, position, rules.DuplicateSuppressionMeters))
			{
				_activeStrokes.Remove(source);
				return false;
			}
			if (value == null || value.Kind != kind)
			{
				StartStroke(source, kind, position);
				return false;
			}
			RoadPoint start = value.Points[value.Points.Count - 1];
			float num = start.HorizontalDistanceTo(in position);
			if (num < rules.MinimumSpacingMeters)
			{
				return false;
			}
			if (num > rules.MaximumGapMeters)
			{
				StartStroke(source, kind, position);
				return false;
			}
			value.Points.Add(position);
			IndexEntry(value, value.Points.Count - 2);
			IsDirty = true;
			segment = new RoadSegment(kind, start, position);
			return true;
		}

		public bool ContainsPointNear(RoadKind kind, RoadPoint position, float radiusMeters)
		{
			return QueryGeometry(kind, position, radiusMeters, null, int.MaxValue);
		}

		public int RemoveCoverage(RoadKind kind, RoadPoint center, float radiusMeters)
		{
			if (radiusMeters <= 0f)
			{
				return 0;
			}
			int num = 0;
			bool flag = false;
			List<RoadStroke> list = new List<RoadStroke>(Strokes.Count);
			List<RoadStroke> list2 = new List<RoadStroke>();
			foreach (RoadStroke stroke in Strokes)
			{
				if (stroke.Kind != kind)
				{
					list.Add(stroke);
					continue;
				}
				List<List<RoadPoint>> list3 = new List<List<RoadPoint>>();
				List<RoadPoint> list4 = null;
				int num2 = 0;
				foreach (RoadPoint point in stroke.Points)
				{
					if (point.HorizontalDistanceTo(in center) <= radiusMeters)
					{
						num2++;
						list4 = null;
						continue;
					}
					if (list4 == null)
					{
						list4 = new List<RoadPoint>();
						list3.Add(list4);
					}
					list4.Add(point);
				}
				if (num2 == 0)
				{
					list.Add(stroke);
					continue;
				}
				num += num2;
				flag = true;
				list2.Add(stroke);
				bool flag2 = true;
				foreach (List<RoadPoint> item in list3)
				{
					RoadStroke roadStroke = new RoadStroke(flag2 ? stroke.Id : Guid.NewGuid(), stroke.Kind, stroke.Source);
					roadStroke.Points.AddRange(item);
					list.Add(roadStroke);
					flag2 = false;
				}
			}
			if (!flag)
			{
				return 0;
			}
			List<RoadObservationSource> list5 = new List<RoadObservationSource>();
			foreach (KeyValuePair<RoadObservationSource, RoadStroke> activeStroke in _activeStrokes)
			{
				if (list2.Contains(activeStroke.Value))
				{
					list5.Add(activeStroke.Key);
				}
			}
			foreach (RoadObservationSource item2 in list5)
			{
				_activeStrokes.Remove(item2);
			}
			Strokes.Clear();
			Strokes.AddRange(list);
			RebuildIndex();
			IsDirty = true;
			return num;
		}

		public MigrationResult RemoveNonConstructionStrokes()
		{
			EndAllStrokes();
			int num = 0;
			int num2 = 0;
			for (int num3 = Strokes.Count - 1; num3 >= 0; num3--)
			{
				RoadStroke roadStroke = Strokes[num3];
				if (roadStroke.Source != RoadObservationSource.Construction)
				{
					num++;
					num2 += roadStroke.Points.Count;
					Strokes.RemoveAt(num3);
				}
			}
			if (num > 0)
			{
				RebuildIndex();
				IsDirty = true;
			}
			return new MigrationResult(num, num2);
		}

		public MaintenanceResult PerformMaintenance()
		{
			EndAllStrokes();
			int num = MergeAdjacentStrokes();
			int num2 = 0;
			foreach (RoadStroke stroke in Strokes)
			{
				if (stroke.Points.Count >= 3)
				{
					List<RoadPoint> list = RoadGeometry.Simplify(stroke.Points, 1f);
					if (list.Count < stroke.Points.Count)
					{
						num2 += stroke.Points.Count - list.Count;
						stroke.Points.Clear();
						stroke.Points.AddRange(list);
					}
				}
			}
			if (num > 0 || num2 > 0)
			{
				RebuildIndex();
				IsDirty = true;
			}
			return new MaintenanceResult(num, num2);
		}

		public void EditStrokes(Action<List<RoadStroke>> edit)
		{
			EndAllStrokes();
			edit(Strokes);
			Strokes.RemoveAll((RoadStroke stroke) => stroke.Points.Count == 0);
			RebuildIndex();
			IsDirty = true;
		}

		public bool TryFindNearestStroke(RoadPoint position, float maxRadiusMeters, bool includeHidden, out RoadStroke? stroke, out float distanceMeters)
		{
			stroke = null;
			distanceMeters = float.MaxValue;
			foreach (RoadStroke stroke2 in Strokes)
			{
				if (stroke2.Hidden && !includeHidden)
				{
					continue;
				}
				List<RoadPoint> points = stroke2.Points;
				for (int i = 0; i < Math.Max(1, points.Count - 1); i++)
				{
					RoadPoint roadPoint = points[i];
					RoadPoint end = ((i + 1 < points.Count) ? points[i + 1] : roadPoint);
					float num = RoadGeometry.HorizontalDistanceToSegment(position, roadPoint, end);
					if (num < distanceMeters)
					{
						distanceMeters = num;
						stroke = stroke2;
					}
				}
			}
			if (stroke != null)
			{
				return distanceMeters <= maxRadiusMeters;
			}
			return false;
		}

		public bool TryGetNearestPointOnRoads(RoadPoint position, float maxRadiusMeters, out RoadPoint nearest, out float distanceMeters)
		{
			nearest = default(RoadPoint);
			distanceMeters = float.MaxValue;
			int num = (int)Math.Ceiling(maxRadiusMeters / 4f);
			int num2 = ToCell(position.X);
			int num3 = ToCell(position.Z);
			RoadKind[] array = new RoadKind[2]
			{
				RoadKind.Dirt,
				RoadKind.Paved
			};
			foreach (RoadKind kind in array)
			{
				for (int j = num2 - num; j <= num2 + num; j++)
				{
					for (int k = num3 - num; k <= num3 + num; k++)
					{
						if (!_grid.TryGetValue(CellKey(kind, j, k), out List<GridEntry> value))
						{
							continue;
						}
						foreach (GridEntry item in value)
						{
							List<RoadPoint> points = item.Stroke.Points;
							RoadPoint roadPoint = points[item.SegmentIndex];
							RoadPoint end = ((item.SegmentIndex + 1 < points.Count) ? points[item.SegmentIndex + 1] : roadPoint);
							RoadPoint roadPoint2 = RoadGeometry.NearestPointOnSegment(position, roadPoint, end);
							float num4 = roadPoint2.HorizontalDistanceTo(in position);
							if (num4 < distanceMeters)
							{
								distanceMeters = num4;
								nearest = roadPoint2;
							}
						}
					}
				}
			}
			return distanceMeters <= maxRadiusMeters;
		}

		public void EndStroke(RoadObservationSource source)
		{
			_activeStrokes.Remove(source);
		}

		public void EndAllStrokes()
		{
			_activeStrokes.Clear();
		}

		public void MarkClean()
		{
			IsDirty = false;
		}

		private int MergeAdjacentStrokes()
		{
			int num = 0;
			bool flag = true;
			while (flag)
			{
				flag = false;
				for (int i = 0; i < Strokes.Count; i++)
				{
					if (flag)
					{
						break;
					}
					RoadStroke roadStroke = Strokes[i];
					for (int j = 0; j < Strokes.Count; j++)
					{
						if (j != i)
						{
							RoadStroke roadStroke2 = Strokes[j];
							if (roadStroke2.Kind == roadStroke.Kind && roadStroke2.Source == roadStroke.Source && TryJoin(roadStroke, roadStroke2))
							{
								Strokes.RemoveAt(j);
								num++;
								flag = true;
								break;
							}
						}
					}
				}
			}
			return num;
		}

		private static bool TryJoin(RoadStroke into, RoadStroke other)
		{
			List<RoadPoint> points = into.Points;
			List<RoadPoint> points2 = other.Points;
			RoadPoint roadPoint = points[0];
			RoadPoint roadPoint2 = points[points.Count - 1];
			RoadPoint other2 = points2[0];
			RoadPoint other3 = points2[points2.Count - 1];
			if (roadPoint2.HorizontalDistanceTo(in other2) <= 2.5f)
			{
				AppendRun(points, points2, reverse: false);
				return true;
			}
			if (roadPoint2.HorizontalDistanceTo(in other3) <= 2.5f)
			{
				AppendRun(points, points2, reverse: true);
				return true;
			}
			if (roadPoint.HorizontalDistanceTo(in other3) <= 2.5f)
			{
				PrependRun(points, points2, reverse: false);
				return true;
			}
			if (roadPoint.HorizontalDistanceTo(in other2) <= 2.5f)
			{
				PrependRun(points, points2, reverse: true);
				return true;
			}
			return false;
		}

		private static void AppendRun(List<RoadPoint> into, List<RoadPoint> run, bool reverse)
		{
			RoadPoint other = into[into.Count - 1];
			int count = run.Count;
			for (int i = 0; i < count; i++)
			{
				RoadPoint item = run[reverse ? (count - 1 - i) : i];
				if (i != 0 || !(item.HorizontalDistanceTo(in other) <= float.Epsilon))
				{
					into.Add(item);
				}
			}
		}

		private static void PrependRun(List<RoadPoint> into, List<RoadPoint> run, bool reverse)
		{
			RoadPoint other = into[0];
			List<RoadPoint> list = new List<RoadPoint>(run.Count);
			int count = run.Count;
			for (int i = 0; i < count; i++)
			{
				RoadPoint item = run[reverse ? (count - 1 - i) : i];
				list.Add(item);
			}
			if (list.Count > 0 && list[list.Count - 1].HorizontalDistanceTo(in other) <= float.Epsilon)
			{
				list.RemoveAt(list.Count - 1);
			}
			into.InsertRange(0, list);
		}

		private void StartStroke(RoadObservationSource source, RoadKind kind, RoadPoint position)
		{
			RoadStroke roadStroke = new RoadStroke(Guid.NewGuid(), kind, source);
			roadStroke.Points.Add(position);
			_activeStrokes[source] = roadStroke;
			Strokes.Add(roadStroke);
			IndexEntry(roadStroke, 0);
			IsDirty = true;
		}

		private bool IsSuppressedDuplicate(RoadStroke? activeStroke, RoadKind kind, RoadPoint position, float radiusMeters)
		{
			if (radiusMeters <= 0f)
			{
				return false;
			}
			int exemptFromSegment = ((activeStroke == null) ? int.MaxValue : (activeStroke.Points.Count - 1 - 3));
			return QueryGeometry(kind, position, radiusMeters, activeStroke, exemptFromSegment);
		}

		private bool QueryGeometry(RoadKind kind, RoadPoint position, float radiusMeters, RoadStroke? activeStroke, int exemptFromSegment)
		{
			int num = (int)Math.Ceiling(radiusMeters / 4f);
			int num2 = ToCell(position.X);
			int num3 = ToCell(position.Z);
			for (int i = num2 - num; i <= num2 + num; i++)
			{
				for (int j = num3 - num; j <= num3 + num; j++)
				{
					if (!_grid.TryGetValue(CellKey(kind, i, j), out List<GridEntry> value))
					{
						continue;
					}
					foreach (GridEntry item in value)
					{
						if ((item.Stroke != activeStroke || item.SegmentIndex < exemptFromSegment) && EntryDistance(item, position) <= radiusMeters)
						{
							return true;
						}
					}
				}
			}
			return false;
		}

		private static float EntryDistance(GridEntry entry, RoadPoint position)
		{
			List<RoadPoint> points = entry.Stroke.Points;
			RoadPoint roadPoint = points[entry.SegmentIndex];
			RoadPoint end = ((entry.SegmentIndex + 1 < points.Count) ? points[entry.SegmentIndex + 1] : roadPoint);
			return RoadGeometry.HorizontalDistanceToSegment(position, roadPoint, end);
		}

		private void RebuildIndex()
		{
			_grid.Clear();
			foreach (RoadStroke stroke in Strokes)
			{
				IndexStroke(stroke);
			}
		}

		private void IndexStroke(RoadStroke stroke)
		{
			if (stroke.Points.Count == 1)
			{
				IndexEntry(stroke, 0);
				return;
			}
			for (int i = 0; i < stroke.Points.Count - 1; i++)
			{
				IndexEntry(stroke, i);
			}
		}

		private void IndexEntry(RoadStroke stroke, int segmentIndex)
		{
			List<RoadPoint> points = stroke.Points;
			RoadPoint roadPoint = points[segmentIndex];
			RoadPoint roadPoint2 = ((segmentIndex + 1 < points.Count) ? points[segmentIndex + 1] : roadPoint);
			int num = ToCell(Math.Min(roadPoint.X, roadPoint2.X));
			int num2 = ToCell(Math.Max(roadPoint.X, roadPoint2.X));
			int num3 = ToCell(Math.Min(roadPoint.Z, roadPoint2.Z));
			int num4 = ToCell(Math.Max(roadPoint.Z, roadPoint2.Z));
			for (int i = num; i <= num2; i++)
			{
				for (int j = num3; j <= num4; j++)
				{
					long key = CellKey(stroke.Kind, i, j);
					if (!_grid.TryGetValue(key, out List<GridEntry> value))
					{
						value = new List<GridEntry>();
						_grid.Add(key, value);
					}
					value.Add(new GridEntry(stroke, segmentIndex));
				}
			}
		}

		private static int ToCell(float coordinate)
		{
			return (int)Math.Floor(coordinate / 4f);
		}

		private static long CellKey(RoadKind kind, int cellX, int cellZ)
		{
			return (long)((ulong)((long)kind << 62) ^ ((ulong)(uint)cellX << 31) ^ (uint)cellZ);
		}
	}
	internal static class RoadAtlasCodec
	{
		public sealed class ParseResult
		{
			public List<RoadStroke> Strokes { get; }

			public int MalformedRows { get; }

			public int LegacyRows { get; }

			public ParseResult(List<RoadStroke> strokes, int malformedRows, int legacyRows)
			{
				Strokes = strokes;
				MalformedRows = malformedRows;
				LegacyRows = legacyRows;
			}
		}

		public const string Header = "# ConcernedCartographer roads v3";

		private const string RowMarkerV1 = "1";

		private const string RowMarkerV2 = "2";

		private const string RowMarkerV3 = "3";

		private const int HiddenFlag = 1;

		public static ParseResult Parse(IEnumerable<string> lines)
		{
			List<RoadStroke> list = new List<RoadStroke>();
			Dictionary<Guid, RoadStroke> dictionary = new Dictionary<Guid, RoadStroke>();
			int num = 0;
			int num2 = 0;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0 || text.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				if (!TryParseRow(text.Split(new char[1] { '\t' }), out var strokeId, out var kind, out var pointIndex, out var point, out var source, out var hidden, out var isLegacyRow))
				{
					num++;
					continue;
				}
				if (isLegacyRow)
				{
					num2++;
				}
				if (!dictionary.TryGetValue(strokeId, out var value))
				{
					value = new RoadStroke(strokeId, kind, source)
					{
						Hidden = hidden
					};
					dictionary.Add(strokeId, value);
					list.Add(value);
				}
				if (value.Kind != kind || value.Source != source || value.Hidden != hidden || pointIndex != value.Points.Count)
				{
					num++;
				}
				else
				{
					value.Points.Add(point);
				}
			}
			list.RemoveAll((RoadStroke stroke) => stroke.Points.Count == 0);
			return new ParseResult(list, num, num2);
		}

		public static IEnumerable<string> Serialize(IEnumerable<RoadStroke> strokes)
		{
			yield return "# ConcernedCartographer roads v3";
			foreach (RoadStroke stroke in strokes)
			{
				string flags = (stroke.Hidden ? 1 : 0).ToString(CultureInfo.InvariantCulture);
				for (int index = 0; index < stroke.Points.Count; index++)
				{
					RoadPoint roadPoint = stroke.Points[index];
					yield return string.Join("\t", stroke.Id.ToString("D", CultureInfo.InvariantCulture), stroke.Kind.ToString(), index.ToString(CultureInfo.InvariantCulture), roadPoint.X.ToString("R", CultureInfo.InvariantCulture), roadPoint.Y.ToString("R", CultureInfo.InvariantCulture), roadPoint.Z.ToString("R", CultureInfo.InvariantCulture), stroke.Source.ToString(), flags, "3");
				}
			}
		}

		private static bool TryParseRow(string[] parts, out Guid strokeId, out RoadKind kind, out int pointIndex, out RoadPoint point, out RoadObservationSource source, out bool hidden, out bool isLegacyRow)
		{
			strokeId = default(Guid);
			kind = (RoadKind)0;
			pointIndex = 0;
			point = default(RoadPoint);
			source = RoadObservationSource.Traversal;
			hidden = false;
			isLegacyRow = parts.Length == 7;
			if (parts.Length < 7 || parts.Length > 9)
			{
				return false;
			}
			if (!Guid.TryParse(parts[0], out strokeId) || !Enum.TryParse<RoadKind>(parts[1], ignoreCase: true, out kind) || !Enum.IsDefined(typeof(RoadKind), kind) || !int.TryParse(parts[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out pointIndex) || !TryParseFloat(parts[3], out var result) || !TryParseFloat(parts[4], out var result2) || !TryParseFloat(parts[5], out var result3) || float.IsNaN(result) || float.IsInfinity(result) || float.IsNaN(result2) || float.IsInfinity(result2) || float.IsNaN(result3) || float.IsInfinity(result3))
			{
				return false;
			}
			if (parts.Length == 7)
			{
				if (parts[6] != "1")
				{
					return false;
				}
			}
			else
			{
				if (!Enum.TryParse<RoadObservationSource>(parts[6], ignoreCase: true, out source) || !Enum.IsDefined(typeof(RoadObservationSource), source))
				{
					return false;
				}
				if (parts.Length == 8)
				{
					if (parts[7] != "2")
					{
						return false;
					}
				}
				else
				{
					if (!int.TryParse(parts[7], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4) || parts[8] != "3")
					{
						return false;
					}
					hidden = (result4 & 1) != 0;
				}
			}
			point = new RoadPoint(result, result2, result3);
			return true;
		}

		private static bool TryParseFloat(string value, out float result)
		{
			return float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out result);
		}
	}
	internal sealed class RoadAtlasEditor
	{
		private sealed class UndoRecord
		{
			public string Operation { get; }

			public List<RoadStroke> Before { get; }

			public List<RoadStroke> After { get; }

			public UndoRecord(string operation, List<RoadStroke> before, List<RoadStroke> after)
			{
				Operation = operation;
				Before = before;
				After = after;
			}
		}

		public const float DefaultSelectRadiusMeters = 10f;

		private const int UndoDepth = 20;

		private readonly RoadAtlas _atlas;

		private readonly List<UndoRecord> _undo = new List<UndoRecord>();

		public int UndoCount => _undo.Count;

		public RoadAtlasEditor(RoadAtlas atlas)
		{
			_atlas = atlas;
		}

		public bool DeleteNearest(RoadPoint position, float maxRadiusMeters, out string summary)
		{
			if (!_atlas.TryFindNearestStroke(position, maxRadiusMeters, includeHidden: true, out RoadStroke stroke, out float distanceMeters))
			{
				summary = NothingNearby(maxRadiusMeters);
				return false;
			}
			PushUndo("delete", new RoadStroke[1] { stroke }, Array.Empty<RoadStroke>());
			_atlas.EditStrokes(delegate(List<RoadStroke> strokes)
			{
				strokes.Remove(stroke);
			});
			summary = $"Deleted {Describe(stroke)} ({distanceMeters:0.#} m away). 'cc_roads undo' restores it.";
			return true;
		}

		public bool ReclassifyNearest(RoadPoint position, float maxRadiusMeters, out string summary)
		{
			if (!_atlas.TryFindNearestStroke(position, maxRadiusMeters, includeHidden: true, out RoadStroke stroke, out float _))
			{
				summary = NothingNearby(maxRadiusMeters);
				return false;
			}
			RoadKind roadKind = ((stroke.Kind != RoadKind.Dirt) ? RoadKind.Dirt : RoadKind.Paved);
			RoadStroke replacement = new RoadStroke(stroke.Id, roadKind, stroke.Source)
			{
				Hidden = stroke.Hidden
			};
			replacement.Points.AddRange(stroke.Points);
			PushUndo("reclassify", new RoadStroke[1] { stroke }, new RoadStroke[1] { replacement });
			_atlas.EditStrokes(delegate(List<RoadStroke> strokes)
			{
				strokes.Remove(stroke);
				strokes.Add(replacement);
			});
			summary = $"Reclassified {Describe(stroke)} to {roadKind}.";
			return true;
		}

		public bool SetHiddenNearest(RoadPoint position, float maxRadiusMeters, bool hidden, out string summary)
		{
			RoadStroke stroke = FindNearestWithHidden(position, maxRadiusMeters, !hidden);
			if (stroke == null)
			{
				summary = (hidden ? NothingNearby(maxRadiusMeters) : $"No hidden road within {maxRadiusMeters:0.#} m.");
				return false;
			}
			RoadStroke replacement = new RoadStroke(stroke.Id, stroke.Kind, stroke.Source)
			{
				Hidden = hidden
			};
			replacement.Points.AddRange(stroke.Points);
			PushUndo(hidden ? "hide" : "unhide", new RoadStroke[1] { stroke }, new RoadStroke[1] { replacement });
			_atlas.EditStrokes(delegate(List<RoadStroke> strokes)
			{
				strokes.Remove(stroke);
				strokes.Add(replacement);
			});
			summary = (hidden ? "Hid" : "Unhid") + " " + Describe(replacement) + ".";
			return true;
		}

		public bool SplitNearest(RoadPoint position, float maxRadiusMeters, out string summary)
		{
			if (!_atlas.TryFindNearestStroke(position, maxRadiusMeters, includeHidden: true, out RoadStroke stroke, out float _))
			{
				summary = NothingNearby(maxRadiusMeters);
				return false;
			}
			if (stroke.Points.Count < 3)
			{
				summary = "That road is too short to split.";
				return false;
			}
			int num = -1;
			float num2 = float.MaxValue;
			for (int i = 1; i < stroke.Points.Count - 1; i++)
			{
				float num3 = stroke.Points[i].HorizontalDistanceTo(in position);
				if (num3 < num2)
				{
					num2 = num3;
					num = i;
				}
			}
			RoadStroke head = new RoadStroke(stroke.Id, stroke.Kind, stroke.Source)
			{
				Hidden = stroke.Hidden
			};
			head.Points.AddRange(stroke.Points.GetRange(0, num + 1));
			RoadStroke tail = new RoadStroke(Guid.NewGuid(), stroke.Kind, stroke.Source)
			{
				Hidden = stroke.Hidden
			};
			tail.Points.AddRange(stroke.Points.GetRange(num, stroke.Points.Count - num));
			PushUndo("split", new RoadStroke[1] { stroke }, new RoadStroke[2] { head, tail });
			_atlas.EditStrokes(delegate(List<RoadStroke> strokes)
			{
				strokes.Remove(stroke);
				strokes.Add(head);
				strokes.Add(tail);
			});
			summary = $"Split {Describe(stroke)} into {head.Points.Count} + {tail.Points.Count} points at the shared point.";
			return true;
		}

		public bool JoinNearest(RoadPoint position, float maxRadiusMeters, out string summary)
		{
			RoadStroke roadStroke = null;
			RoadStroke roadStroke2 = null;
			float num = float.MaxValue;
			List<RoadStroke> strokes = _atlas.Strokes;
			for (int i = 0; i < strokes.Count; i++)
			{
				foreach (RoadPoint item in Endpoints(strokes[i]))
				{
					if (item.HorizontalDistanceTo(in position) > maxRadiusMeters)
					{
						continue;
					}
					for (int j = i + 1; j < strokes.Count; j++)
					{
						if (strokes[j].Kind != strokes[i].Kind || strokes[j].Source != strokes[i].Source)
						{
							continue;
						}
						foreach (RoadPoint item2 in Endpoints(strokes[j]))
						{
							RoadPoint other = item2;
							float num2 = item.HorizontalDistanceTo(in other);
							if (other.HorizontalDistanceTo(in position) <= maxRadiusMeters && num2 < num)
							{
								num = num2;
								roadStroke = strokes[i];
								roadStroke2 = strokes[j];
							}
						}
					}
				}
			}
			if (roadStroke == null || roadStroke2 == null)
			{
				summary = $"No two same-kind road ends within {maxRadiusMeters:0.#} m of you.";
				return false;
			}
			RoadStroke joined = new RoadStroke(roadStroke.Id, roadStroke.Kind, roadStroke.Source)
			{
				Hidden = roadStroke.Hidden
			};
			joined.Points.AddRange(roadStroke.Points);
			AppendNearestEndFirst(joined.Points, roadStroke2.Points);
			PushUndo("join", new RoadStroke[2] { roadStroke, roadStroke2 }, new RoadStroke[1] { joined });
			RoadStroke firstCaptured = roadStroke;
			RoadStroke secondCaptured = roadStroke2;
			_atlas.EditStrokes(delegate(List<RoadStroke> list)
			{
				list.Remove(firstCaptured);
				list.Remove(secondCaptured);
				list.Add(joined);
			});
			summary = $"Joined two {joined.Kind} roads into one ({joined.Points.Count} points, ends were {num:0.#} m apart).";
			return true;
		}

		public bool Undo(out string summary)
		{
			if (_undo.Count == 0)
			{
				summary = "Nothing to undo.";
				return false;
			}
			UndoRecord record = _undo[_undo.Count - 1];
			_undo.RemoveAt(_undo.Count - 1);
			_atlas.EditStrokes(delegate(List<RoadStroke> strokes)
			{
				foreach (RoadStroke item in record.After)
				{
					strokes.Remove(item);
				}
				foreach (RoadStroke item2 in record.Before)
				{
					strokes.Add(item2);
				}
			});
			summary = $"Undid '{record.Operation}'; {record.Before.Count} road(s) restored.";
			return true;
		}

		public string DescribeNearest(RoadPoint position, float maxRadiusMeters)
		{
			if (!_atlas.TryFindNearestStroke(position, maxRadiusMeters, includeHidden: true, out RoadStroke stroke, out float distanceMeters))
			{
				return NothingNearby(maxRadiusMeters);
			}
			return "Nearest: " + Describe(stroke) + ", " + distanceMeters.ToString("0.#", CultureInfo.InvariantCulture) + " m away.";
		}

		private RoadStroke? FindNearestWithHidden(RoadPoint position, float maxRadiusMeters, bool hidden)
		{
			RoadStroke result = null;
			float num = maxRadiusMeters;
			foreach (RoadStroke stroke in _atlas.Strokes)
			{
				if (stroke.Hidden != hidden)
				{
					continue;
				}
				foreach (RoadPoint point in stroke.Points)
				{
					float num2 = point.HorizontalDistanceTo(in position);
					if (num2 <= num)
					{
						num = num2;
						result = stroke;
					}
				}
			}
			return result;
		}

		private static IEnumerable<RoadPoint> Endpoints(RoadStroke stroke)
		{
			yield return stroke.Points[0];
			if (stroke.Points.Count > 1)
			{
				yield return stroke.Points[stroke.Points.Count - 1];
			}
		}

		private static void AppendNearestEndFirst(List<RoadPoint> into, List<RoadPoint> run)
		{
			RoadPoint other = into[into.Count - 1];
			bool flag = run[run.Count - 1].HorizontalDistanceTo(in other) < run[0].HorizontalDistanceTo(in other);
			int count = run.Count;
			for (int i = 0; i < count; i++)
			{
				into.Add(run[flag ? (count - 1 - i) : i]);
			}
		}

		private void PushUndo(string operation, IReadOnlyList<RoadStroke> before, IReadOnlyList<RoadStroke> after)
		{
			List<RoadStroke> list = new List<RoadStroke>(before.Count);
			foreach (RoadStroke item in before)
			{
				RoadStroke roadStroke = new RoadStroke(item.Id, item.Kind, item.Source)
				{
					Hidden = item.Hidden
				};
				roadStroke.Points.AddRange(item.Points);
				list.Add(roadStroke);
			}
			_undo.Add(new UndoRecord(operation, list, new List<RoadStroke>(after)));
			if (_undo.Count > 20)
			{
				_undo.RemoveAt(0);
			}
		}

		private static string Describe(RoadStroke stroke)
		{
			string text = (stroke.Hidden ? ", hidden" : "");
			return $"a {stroke.Kind} road ({stroke.Points.Count} points, recorded by {stroke.Source}{text})";
		}

		private static string NothingNearby(float maxRadiusMeters)
		{
			return "No recorded road within " + maxRadiusMeters.ToString("0.#", CultureInfo.InvariantCulture) + " m of you.";
		}
	}
	internal static class RoadGeometry
	{
		public static RoadPoint NearestPointOnSegment(RoadPoint point, RoadPoint start, RoadPoint end)
		{
			float num = end.X - start.X;
			float num2 = end.Z - start.Z;
			float num3 = num * num + num2 * num2;
			if (num3 <= float.Epsilon)
			{
				return start;
			}
			float val = ((point.X - start.X) * num + (point.Z - start.Z) * num2) / num3;
			val = Math.Max(0f, Math.Min(1f, val));
			return new RoadPoint(start.X + val * num, start.Y, start.Z + val * num2);
		}

		public static float HorizontalDistanceToSegment(RoadPoint point, RoadPoint start, RoadPoint end)
		{
			float num = end.X - start.X;
			float num2 = end.Z - start.Z;
			float num3 = num * num + num2 * num2;
			if (num3 <= float.Epsilon)
			{
				return start.HorizontalDistanceTo(in point);
			}
			float val = ((point.X - start.X) * num + (point.Z - start.Z) * num2) / num3;
			val = Math.Max(0f, Math.Min(1f, val));
			float num4 = start.X + val * num;
			float num5 = start.Z + val * num2;
			float num6 = point.X - num4;
			float num7 = point.Z - num5;
			return (float)Math.Sqrt(num6 * num6 + num7 * num7);
		}

		public static List<RoadPoint> Simplify(IReadOnlyList<RoadPoint> points, float toleranceMeters)
		{
			List<RoadPoint> list = new List<RoadPoint>();
			if (points.Count <= 2 || toleranceMeters <= 0f)
			{
				for (int i = 0; i < points.Count; i++)
				{
					list.Add(points[i]);
				}
				return list;
			}
			bool[] array = new bool[points.Count];
			array[0] = true;
			array[points.Count - 1] = true;
			Stack<(int, int)> stack = new Stack<(int, int)>();
			stack.Push((0, points.Count - 1));
			while (stack.Count > 0)
			{
				var (num, num2) = stack.Pop();
				if (num2 - num < 2)
				{
					continue;
				}
				float num3 = -1f;
				int num4 = -1;
				for (int j = num + 1; j < num2; j++)
				{
					float num5 = HorizontalDistanceToSegment(points[j], points[num], points[num2]);
					if (num5 > num3)
					{
						num3 = num5;
						num4 = j;
					}
				}
				if (num3 > toleranceMeters)
				{
					array[num4] = true;
					stack.Push((num, num4));
					stack.Push((num4, num2));
				}
			}
			for (int k = 0; k < points.Count; k++)
			{
				if (array[k])
				{
					list.Add(points[k]);
				}
			}
			return list;
		}
	}
	internal static class RoadInkSoftening
	{
		public const float WidenFactor = 1.3333334f;

		public const float OpaqueCoreFraction = 0.5f;

		public static float Alpha(float normalizedOffsetFromCenter)
		{
			float num = Math.Abs(normalizedOffsetFromCenter);
			if (num >= 1f)
			{
				return 0f;
			}
			if (num <= 0.5f)
			{
				return 1f;
			}
			return (1f - num) / 0.5f;
		}
	}
	internal enum RoadKind
	{
		Dirt = 1,
		Paved
	}
	internal readonly struct RoadObservation
	{
		public RoadObservationSource Source { get; }

		public RoadKind Kind { get; }

		public RoadPoint Position { get; }

		public RoadObservation(RoadObservationSource source, RoadKind kind, RoadPoint position)
		{
			Source = source;
			Kind = kind;
			Position = position;
		}

		public override string ToString()
		{
			return $"{Source}/{Kind} @ {Position}";
		}
	}
	internal sealed class RoadObservationPipeline
	{
		private const float ReplayEpsilonMeters = 0.05f;

		private readonly RoadAtlas _atlas;

		private readonly TerrainIntentMask? _terrainIntent;

		public RoadObservation? LastAccepted { get; private set; }

		public RoadObservationPipeline(RoadAtlas atlas, TerrainIntentMask? terrainIntent = null)
		{
			_atlas = atlas;
			_terrainIntent = terrainIntent;
		}

		public bool Observe(in RoadObservation observation, RoadSamplingRules rules, out RoadSegment segment)
		{
			if (observation.Source != RoadObservationSource.Construction)
			{
				_atlas.EndStroke(observation.Source);
				segment = default(RoadSegment);
				return false;
			}
			if (_terrainIntent != null && observation.Kind == RoadKind.Dirt && observation.Source != RoadObservationSource.Construction && _terrainIntent.IsExcluded(observation.Position.X, observation.Position.Z))
			{
				_atlas.EndStroke(observation.Source);
				segment = default(RoadSegment);
				return false;
			}
			if (_atlas.ContainsPointNear(observation.Kind, observation.Position, 0.05f))
			{
				segment = default(RoadSegment);
				return false;
			}
			bool num = _atlas.RecordSample(observation.Source, observation.Kind, observation.Position, rules, out segment);
			if (num || _atlas.ContainsPointNear(observation.Kind, observation.Position, 0.05f))
			{
				LastAccepted = observation;
			}
			return num;
		}

		public void EndStroke(RoadObservationSource source)
		{
			_atlas.EndStroke(source);
		}

		public void EndAllStrokes()
		{
			_atlas.EndAllStrokes();
		}
	}
	internal enum RoadObservationSource
	{
		Traversal = 1,
		Construction,
		ChunkRecovery
	}
	internal readonly struct RoadPoint
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public RoadPoint(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public float HorizontalDistanceTo(in RoadPoint other)
		{
			float num = X - other.X;
			float num2 = Z - other.Z;
			return (float)Math.Sqrt(num * num + num2 * num2);
		}

		public override string ToString()
		{
			return string.Format(CultureInfo.InvariantCulture, "({0:0.##}, {1:0.##}, {2:0.##})", X, Y, Z);
		}
	}
	internal readonly struct RoadSamplingRules
	{
		public float MinimumSpacingMeters { get; }

		public float MaximumGapMeters { get; }

		public float DuplicateSuppressionMeters { get; }

		public RoadSamplingRules(float minimumSpacingMeters, float maximumGapMeters, float duplicateSuppressionMeters)
		{
			MinimumSpacingMeters = minimumSpacingMeters;
			MaximumGapMeters = maximumGapMeters;
			DuplicateSuppressionMeters = duplicateSuppressionMeters;
		}
	}
	internal readonly struct RoadSegment
	{
		public RoadKind Kind { get; }

		public RoadPoint Start { get; }

		public RoadPoint End { get; }

		public RoadSegment(RoadKind kind, RoadPoint start, RoadPoint end)
		{
			Kind = kind;
			Start = start;
			End = end;
		}
	}
	internal sealed class RoadStroke
	{
		public Guid Id { get; }

		public RoadKind Kind { get; }

		public RoadObservationSource Source { get; }

		public bool Hidden { get; set; }

		public List<RoadPoint> Points { get; } = new List<RoadPoint>();

		public RoadStroke(Guid id, RoadKind kind, RoadObservationSource source = RoadObservationSource.Traversal)
		{
			Id = id;
			Kind = kind;
			Source = source;
		}
	}
	internal static class RoadVectorMath
	{
		public const float ReferenceSize = 2048f;

		public static (float X, float Y) Bake(float mapX, float mapY)
		{
			return (X: (mapX - 0.5f) * 2048f, Y: (mapY - 0.5f) * 2048f);
		}

		public static (float ScaleX, float ScaleY, float PositionX, float PositionY) ContentTransform(float uvMinX, float uvMinY, float uvWidth, float uvHeight, float rectWidth, float rectHeight)
		{
			float item = rectWidth / (2048f * uvWidth);
			float item2 = rectHeight / (2048f * uvHeight);
			float item3 = (0.5f - uvMinX) / uvWidth * rectWidth;
			float item4 = (0.5f - uvMinY) / uvHeight * rectHeight;
			return (ScaleX: item, ScaleY: item2, PositionX: item3, PositionY: item4);
		}

		public static float BakedHalfWidth(float screenPixels, float uvWidth, float rectWidth)
		{
			if (rectWidth <= 0f)
			{
				return screenPixels / 2f;
			}
			return screenPixels * 2048f * uvWidth / rectWidth / 2f;
		}

		public static (float X, float Y) VanillaLocalGuiPosition(float mapX, float mapY, float uvMinX, float uvMinY, float uvWidth, float uvHeight, float rectWidth, float rectHeight)
		{
			return (X: (mapX - uvMinX) / uvWidth * rectWidth, Y: (mapY - uvMinY) / uvHeight * rectHeight);
		}
	}
	internal enum TerrainActionCategory
	{
		Unknown,
		Pathen,
		PavedRoad,
		LevelGround,
		RaiseGround,
		Cultivate,
		Replant,
		Digging
	}
	internal readonly struct TerrainActionClassification
	{
		public TerrainActionCategory Category { get; }

		public RoadKind? RoadKind { get; }

		public bool ErasesRoads { get; }

		public bool SelectionMismatch { get; }

		public string Description { get; }

		public TerrainActionClassification(TerrainActionCategory category, RoadKind? roadKind, bool erasesRoads, bool selectionMismatch, string description)
		{
			Category = category;
			RoadKind = roadKind;
			ErasesRoads = erasesRoads;
			SelectionMismatch = selectionMismatch;
			Description = description;
		}
	}
	internal static class TerrainActionClassifier
	{
		public static TerrainActionClassification Classify(string? operationObjectName, string? pieceNameToken, string? selectedPieceName, bool paintCleared, TerrainPaintKind paint)
		{
			string text = NormalizePrefabName(operationObjectName);
			TerrainActionCategory terrainActionCategory = CategoryOfPrefab(text);
			if (terrainActionCategory == TerrainActionCategory.Unknown)
			{
				terrainActionCategory = CategoryOfPieceToken(pieceNameToken);
			}
			RoadKind? roadKind = null;
			if (paintCleared)
			{
				if (terrainActionCategory == TerrainActionCategory.Pathen && paint == TerrainPaintKind.Dirt)
				{
					roadKind = RoadKind.Dirt;
				}
				else if (terrainActionCategory == TerrainActionCategory.PavedRoad && paint == TerrainPaintKind.Paved)
				{
					roadKind = RoadKind.Paved;
				}
			}
			bool selectionMismatch = false;
			if (roadKind.HasValue && !string.IsNullOrEmpty(selectedPieceName) && CategoryOfPrefab(NormalizePrefabName(selectedPieceName)) != terrainActionCategory)
			{
				selectionMismatch = true;
				roadKind = null;
			}
			bool erasesRoads = paintCleared && !roadKind.HasValue;
			string description = Describe(terrainActionCategory, text, paint, roadKind, erasesRoads, selectionMismatch, selectedPieceName);
			return new TerrainActionClassification(terrainActionCategory, roadKind, erasesRoads, selectionMismatch, description);
		}

		public static string NormalizePrefabName(string? objectName)
		{
			if (string.IsNullOrEmpty(objectName))
			{
				return string.Empty;
			}
			string text = objectName.Trim();
			while (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(Array.Empty<char>());
			}
			return text.ToLowerInvariant();
		}

		private static TerrainActionCategory CategoryOfPrefab(string normalizedName)
		{
			switch (normalizedName)
			{
			case "path_v2":
			case "path":
				return TerrainActionCategory.Pathen;
			case "paved_road":
			case "paved_road_v2":
				return TerrainActionCategory.PavedRoad;
			case "mud_road":
			case "mud_road_v2":
				return TerrainActionCategory.LevelGround;
			case "raise_v2":
			case "raise":
				return TerrainActionCategory.RaiseGround;
			case "cultivate_v2":
			case "cultivate":
				return TerrainActionCategory.Cultivate;
			case "replant":
			case "replant_v2":
				return TerrainActionCategory.Replant;
			case "digg_v2":
			case "digg":
				return TerrainActionCategory.Digging;
			default:
				return TerrainActionCategory.Unknown;
			}
		}

		private static TerrainActionCategory CategoryOfPieceToken(string? token)
		{
			if (string.IsNullOrEmpty(token))
			{
				return TerrainActionCategory.Unknown;
			}
			return token.Trim().TrimStart(new char[1] { '$' }).ToLowerInvariant() switch
			{
				"piece_pathen" => TerrainActionCategory.Pathen, 
				"piece_pavedroad" => TerrainActionCategory.PavedRoad, 
				"piece_level" => TerrainActionCategory.LevelGround, 
				"piece_raise" => TerrainActionCategory.RaiseGround, 
				"piece_cultivate" => TerrainActionCategory.Cultivate, 
				"piece_replant" => TerrainActionCategory.Replant, 
				_ => TerrainActionCategory.Unknown, 
			};
		}

		private static string Describe(TerrainActionCategory category, string operationName, TerrainPaintKind paint, RoadKind? roadKind, bool erasesRoads, bool selectionMismatch, string? selectedPieceName)
		{
			string text = ((operationName.Length == 0) ? "<unnamed op>" : operationName);
			object obj;
			if (!roadKind.HasValue)
			{
				obj = (erasesRoads ? "no road (erases covered ink)" : "no road");
			}
			else
			{
				RoadKind valueOrDefault = roadKind.GetValueOrDefault();
				obj = $"{valueOrDefault} road";
			}
			string text2 = (string)obj;
			string text3 = (selectionMismatch ? (" [REFUSED: selected piece '" + NormalizePrefabName(selectedPieceName) + "' disagrees]") : string.Empty);
			return $"{CategoryLabel(category)} ({text}) paint={paint} => {text2}{text3}";
		}

		private static string CategoryLabel(TerrainActionCategory category)
		{
			return category switch
			{
				TerrainActionCategory.Pathen => "pathen", 
				TerrainActionCategory.PavedRoad => "paved-road", 
				TerrainActionCategory.LevelGround => "level-ground", 
				TerrainActionCategory.RaiseGround => "raise-ground", 
				TerrainActionCategory.Cultivate => "cultivate", 
				TerrainActionCategory.Replant => "replant", 
				TerrainActionCategory.Digging => "digging", 
				_ => "unknown-action", 
			};
		}
	}
	internal static class TerrainIntentCodec
	{
		public sealed class ParseResult
		{
			public TerrainIntentMask Mask { get; }

			public int MalformedRows { get; }

			public bool UnsupportedVersion { get; }

			public ParseResult(TerrainIntentMask mask, int malformedRows, bool unsupportedVersion)
			{
				Mask = mask;
				MalformedRows = malformedRows;
				UnsupportedVersion = unsupportedVersion;
			}
		}

		public const string HeaderName = "cc-terrain-intent";

		public const string Version = "v1";

		public static IEnumerable<string> Serialize(TerrainIntentMask mask)
		{
			yield return "cc-terrain-intent\tv1";
			foreach (var (num, num2) in mask.Cells)
			{
				yield return string.Format(CultureInfo.InvariantCulture, "cell\t{0}\t{1}", num, num2);
			}
		}

		public static ParseResult Parse(IEnumerable<string> lines)
		{
			List<(int, int)> list = new List<(int, int)>();
			int num = 0;
			bool flag = false;
			foreach (string line in lines)
			{
				string text = line.Trim();
				if (text.Length == 0)
				{
					continue;
				}
				if (!flag)
				{
					flag = true;
					string[] array = text.Split(new char[1] { '\t' });
					if (array.Length < 2 || array[0] != "cc-terrain-intent" || array[1] != "v1")
					{
						return new ParseResult(new TerrainIntentMask(), 0, unsupportedVersion: true);
					}
				}
				else
				{
					string[] array2 = text.Split(new char[1] { '\t' });
					if (array2.Length == 3 && array2[0] == "cell" && int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && list.Count < 250000)
					{
						list.Add((result, result2));
					}
					else
					{
						num++;
					}
				}
			}
			return new ParseResult(new TerrainIntentMask(list), num, unsupportedVersion: false);
		}
	}
	internal sealed class TerrainIntentMask
	{
		public const float CellSizeMeters = 1f;

		public const float BrushMarginMeters = 1f;

		public const int DefaultMaxCells = 250000;

		private readonly HashSet<long> _cells = new HashSet<long>();

		private readonly Queue<long> _insertionOrder = new Queue<long>();

		private readonly int _maxCells;

		public int Count => _cells.Count;

		public bool IsDirty { get; private set; }

		public IEnumerable<(int Cx, int Cz)> Cells
		{
			get
			{
				foreach (long cell in _cells)
				{
					yield return Unpack(cell);
				}
			}
		}

		public TerrainIntentMask(int maxCells = 250000)
		{
			_maxCells = Math.Max(1, maxCells);
		}

		public TerrainIntentMask(IEnumerable<(int Cx, int Cz)> cells, int maxCells = 250000)
			: this(maxCells)
		{
			foreach (var cell in cells)
			{
				int item = cell.Cx;
				int item2 = cell.Cz;
				long item3 = Pack(item, item2);
				if (_cells.Add(item3))
				{
					_insertionOrder.Enqueue(item3);
				}
				if (_cells.Count > _maxCells)
				{
					EvictOldest();
				}
			}
			IsDirty = false;
		}

		public bool IsExcluded(float x, float z)
		{
			return _cells.Contains(Pack(CellOf(x), CellOf(z)));
		}

		public int AddExclusion(float centerX, float centerZ, float radiusMeters)
		{
			int added = 0;
			ForEachCellInDisk(centerX, centerZ, radiusMeters, delegate(long key)
			{
				if (_cells.Add(key))
				{
					_insertionOrder.Enqueue(key);
					added++;
				}
			});
			while (_cells.Count > _maxCells)
			{
				EvictOldest();
			}
			if (added > 0)
			{
				IsDirty = true;
			}
			return added;
		}

		public int ClearExclusion(float centerX, float centerZ, float radiusMeters)
		{
			int cleared = 0;
			ForEachCellInDisk(centerX, centerZ, radiusMeters, delegate(long key)
			{
				if (_cells.Remove(key))
				{
					cleared++;
				}
			});
			if (cleared > 0)
			{
				IsDirty = true;
			}
			return cleared;
		}

		public void MarkClean()
		{
			IsDirty = false;
		}

		private void EvictOldest()
		{
			while (_insertionOrder.Count > 0)
			{
				long item = _insertionOrder.Dequeue();
				if (_cells.Remove(item))
				{
					break;
				}
			}
		}

		private static void ForEachCellInDisk(float centerX, float centerZ, float radiusMeters, Action<long> visit)
		{
			if (radiusMeters <= 0f || float.IsNaN(radiusMeters) || float.IsInfinity(radiusMeters) || float.IsNaN(centerX) || float.IsNaN(centerZ))
			{
				return;
			}
			float num = radiusMeters * radiusMeters;
			int num2 = CellOf(centerX - radiusMeters);
			int num3 = CellOf(centerX + radiusMeters);
			int num4 = CellOf(centerZ - radiusMeters);
			int num5 = CellOf(centerZ + radiusMeters);
			for (int i = num2; i <= num3; i++)
			{
				float num6 = ((float)i + 0.5f) * 1f - centerX;
				for (int j = num4; j <= num5; j++)
				{
					float num7 = ((float)j + 0.5f) * 1f - centerZ;
					if (num6 * num6 + num7 * num7 <= num)
					{
						visit(Pack(i, j));
					}
				}
			}
		}

		private static int CellOf(float coordinate)
		{
			return (int)Math.Floor(coordinate / 1f);
		}

		private static long Pack(int cx, int cz)
		{
			return ((long)cx << 32) | (uint)cz;
		}

		private static (int Cx, int Cz) Unpack(long key)
		{
			return (Cx: (int)(key >> 32), Cz: (int)key);
		}
	}
	internal enum TerrainPaintKind
	{
		None,
		Dirt,
		Cultivate,
		Paved,
		Reset,
		Other
	}
	internal sealed class VectorBakeScheduler
	{
		public const float ZoomStepRatio = 1.25f;

		public const float DebounceSeconds = 0.5f;

		public const float PeriodicSeconds = 30f;

		public const float IncompleteRetrySeconds = 0.25f;

		private float _bakedUvWidth = -1f;

		private bool _dataDirty = true;

		private float _debounceElapsed;

		private float _periodicElapsed;

		public float BakedUvWidth => _bakedUvWidth;

		public bool DataDirty => _dataDirty;

		public void MarkDataDirty()
		{
			_dataDirty = true;
		}

		public void Invalidate()
		{
			_bakedUvWidth = -1f;
			_dataDirty = true;
		}

		public void Advance(float deltaTime)
		{
			if (deltaTime > 0f)
			{
				_debounceElapsed += deltaTime;
				_periodicElapsed += deltaTime;
			}
		}

		public bool ShouldRebake(float uvWidth, bool stylingChanged)
		{
			if (_bakedUvWidth <= 0f || stylingChanged)
			{
				return true;
			}
			if (uvWidth > _bakedUvWidth * 1.25f || uvWidth < _bakedUvWidth / 1.25f)
			{
				return true;
			}
			if (_dataDirty && _debounceElapsed >= 0.5f)
			{
				return true;
			}
			return _periodicElapsed >= 30f;
		}

		public void OnBakeCommitted(float uvWidth)
		{
			_bakedUvWidth = uvWidth;
			_dataDirty = false;
			_debounceElapsed = 0f;
			_periodicElapsed = 0f;
		}

		public void OnBakeIncomplete()
		{
			_dataDirty = true;
			_debounceElapsed = Math.Max(0f, 0.25f);
			_periodicElapsed = 0f;
		}
	}
	internal readonly struct CapturedTerrainOperation
	{
		public RoadKind? RoadKind { get; }

		public Vector3 Position { get; }

		public float RadiusMeters { get; }

		public TerrainActionCategory Category { get; }

		public string ActionDescription { get; }

		public CapturedTerrainOperation(RoadKind? roadKind, Vector3 position, float radiusMeters, TerrainActionCategory category, string actionDescription)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			RoadKind = roadKind;
			Position = position;
			RadiusMeters = radiusMeters;
			Category = category;
			ActionDescription = actionDescription;
		}
	}
	internal sealed class ConstructionCapture : IDisposable
	{
		private static ConstructionCapture? s_active;

		private readonly ManualLogSource _log;

		private Harmony? _harmony;

		private bool _disabledForSession;

		public event Action<CapturedTerrainOperation>? OperationCaptured;

		public ConstructionCapture(ManualLogSource log)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			_log = log;
			try
			{
				_harmony = new Harmony("com.theconcernedcat.valheim.concernedcartographer.construction");
				_harmony.Patch((MethodBase)AccessTools.Method(typeof(TerrainComp), "ApplyOperation", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(ConstructionCapture), "AfterApplyOperation", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				s_active = this;
			}
			catch (Exception exception)
			{
				_harmony = null;
				_log.LogError((object)("Construction capture could not be installed and is disabled for this session: " + SafeLogText.Describe(exception)));
			}
		}

		private static void AfterApplyOperation(TerrainOp modifier)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			ConstructionCapture constructionCapture = s_active;
			if (constructionCapture == null || constructionCapture._disabledForSession)
			{
				return;
			}
			try
			{
				Settings val = (((Object)(object)modifier == (Object)null) ? null : modifier.m_settings);
				if (val != null && val.m_paintCleared)
				{
					TerrainActionClassification terrainActionClassification = TerrainActionClassifier.Classify(((Object)((Component)modifier).gameObject).name, ReadPieceNameToken(modifier), ReadSelectedPieceName(), val.m_paintCleared, MapPaint(val.m_paintType));
					constructionCapture.OperationCaptured?.Invoke(new CapturedTerrainOperation(terrainActionClassification.RoadKind, ((Component)modifier).transform.position, val.m_paintRadius, terrainActionClassification.Category, terrainActionClassification.Description));
				}
			}
			catch (Exception exception)
			{
				constructionCapture._disabledForSession = true;
				constructionCapture._log.LogError((object)("Construction capture failed and is disabled for this session: " + SafeLogText.Describe(exception)));
			}
		}

		private static TerrainPaintKind MapPaint(PaintType paintType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			return (int)paintType switch
			{
				0 => TerrainPaintKind.Dirt, 
				1 => TerrainPaintKind.Cultivate, 
				2 => TerrainPaintKind.Paved, 
				3 => TerrainPaintKind.Reset, 
				_ => TerrainPaintKind.Other, 
			};
		}

		private static string? ReadPieceNameToken(TerrainOp modifier)
		{
			try
			{
				Piece component = ((Component)modifier).GetComponent<Piece>();
				return ((Object)(object)component == (Object)null) ? null : component.m_name;
			}
			catch
			{
				return null;
			}
		}

		private static string? ReadSelectedPieceName()
		{
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return null;
				}
				Piece val = default(Piece);
				Vector2Int val2 = default(Vector2Int);
				int num = default(int);
				PieceCategory val3 = default(PieceCategory);
				PieceTable val4 = default(PieceTable);
				localPlayer.GetBuildSelection(ref val, ref val2, ref num, ref val3, ref val4);
				return ((Object)(object)val == (Object)null) ? null : ((Object)((Component)val).gameObject).name;
			}
			catch
			{
				return null;
			}
		}

		public void Dispose()
		{
			if (s_active == this)
			{
				s_active = null;
			}
			try
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
			_harmony = null;
		}
	}
	internal sealed class GroundPaintProbe
	{
		private readonly CartographerSettings _settings;

		private readonly ManualLogSource _log;

		private readonly RateLimitedLog _rateLimited;

		private readonly List<Heightmap> _heightmaps = new List<Heightmap>();

		private bool _disabledForSession;

		private bool _failureLogged;

		public GroundPaintProbe(CartographerSettings settings, ManualLogSource log)
		{
			_settings = settings;
			_log = log;
			_rateLimited = new RateLimitedLog(log, 5f);
		}

		public bool TryClassify(Vector3 worldPosition, out RoadKind kind)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			kind = (RoadKind)0;
			if (_disabledForSession)
			{
				return false;
			}
			try
			{
				_heightmaps.Clear();
				Heightmap.FindHeightmap(worldPosition, 2f, _heightmaps);
				if (_heightmaps.Count == 0)
				{
					return false;
				}
				Heightmap val = FindNearestHeightmap(worldPosition);
				int num = default(int);
				int num2 = default(int);
				val.WorldToVertex(worldPosition, ref num, ref num2);
				int value = _settings.PaintSampleRadius.Value;
				int width = val.m_width;
				Color val2 = Color.clear;
				int num3 = 0;
				for (int i = num2 - value; i <= num2 + value; i++)
				{
					if (i < 0 || i > width)
					{
						continue;
					}
					for (int j = num - value; j <= num + value; j++)
					{
						if (j >= 0 && j <= width)
						{
							val2 += val.GetPaintMask(j, i);
							num3++;
						}
					}
				}
				if (num3 == 0)
				{
					return false;
				}
				Color val3 = val2 / (float)num3;
				float value2 = _settings.PaintThreshold.Value;
				if (val3.b >= value2 && val3.b > val3.r)
				{
					kind = RoadKind.Paved;
					LogClassification(kind, val3);
					return true;
				}
				if (val3.r >= value2 && val3.r > val3.b)
				{
					kind = RoadKind.Dirt;
					LogClassification(kind, val3);
					return true;
				}
				return false;
			}
			catch (Exception exception)
			{
				_disabledForSession = true;
				if (!_failureLogged)
				{
					_failureLogged = true;
					_log.LogError((object)("Terrain paint probing failed and was disabled for this session: " + SafeLogText.Describe(exception)));
				}
				return false;
			}
		}

		private Heightmap FindNearestHeightmap(Vector3 worldPosition)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Heightmap val = _heightmaps[0];
			float num = HorizontalSqrDistance(((Component)val).transform.position, worldPosition);
			for (int i = 1; i < _heightmaps.Count; i++)
			{
				Heightmap val2 = _heightmaps[i];
				float num2 = HorizontalSqrDistance(((Component)val2).transform.position, worldPosition);
				if (num2 < num)
				{
					val = val2;
					num = num2;
				}
			}
			return val;
		}

		private void LogClassification(RoadKind kind, Color color)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (_settings.DebugLogging.Value)
			{
				_rateLimited.Info($"classify-{kind}", $"Terrain classified as {kind}; paint RGBA={color}.");
			}
		}

		private static float HorizontalSqrDistance(Vector3 left, Vector3 right)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = left.x - right.x;
			float num2 = left.z - right.z;
			return num * num + num2 * num2;
		}
	}
	internal sealed class RoadSurveyor
	{
		public readonly struct TraversalSample
		{
			public Vector3 Position { get; }

			public bool Classified { get; }

			public RoadKind Kind { get; }

			public bool OnRecordedRoad { get; }

			public TraversalSample(Vector3 position, bool classified, RoadKind kind, bool onRecordedRoad)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				Position = position;
				Classified = classified;
				Kind = kind;
				OnRecordedRoad = onRecordedRoad;
			}
		}

		private readonly CartographerSettings _settings;

		private readonly GroundPaintProbe _probe;

		private readonly RoadAtlas _atlas;

		private float _elapsed;

		public TraversalSample? LatestSample { get; private set; }

		public RoadSurveyor(CartographerSettings settings, GroundPaintProbe probe, RoadAtlas atlas, ManualLogSource log)
		{
			_settings = settings;
			_probe = probe;
			_atlas = atlas;
		}

		public void Tick(float deltaTime)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			_elapsed += deltaTime;
			if (_elapsed < _settings.SampleIntervalSeconds.Value)
			{
				return;
			}
			_elapsed = 0f;
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null && !((Character)localPlayer).IsDead())
			{
				Vector3 position = ((Component)localPlayer).transform.position;
				if (!_probe.TryClassify(position, out var kind))
				{
					LatestSample = new TraversalSample(position, classified: false, (RoadKind)0, onRecordedRoad: false);
					return;
				}
				bool onRecordedRoad = _atlas.ContainsPointNear(kind, new RoadPoint(position.x, position.y, position.z), 3f);
				LatestSample = new TraversalSample(position, classified: true, kind, onRecordedRoad);
			}
		}
	}
}