using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("SnakeSquadCartographySnapshot")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+be87a06804e2bdea813de87a1bd3e0099fa35086")]
[assembly: AssemblyProduct("SnakeSquadCartographySnapshot")]
[assembly: AssemblyTitle("SnakeSquadCartographySnapshot")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SnakeSquadCartographySnapshot
{
	[BepInPlugin("com.snakesquad.cartographysnapshot", "SnakeSquad Cartography Snapshot", "1.17.1")]
	public class CartographySnapshotPlugin : BaseUnityPlugin
	{
		private class ConfigurationManagerAttributes
		{
			public Action<ConfigEntryBase>? CustomDrawer;
		}

		[HarmonyPatch(typeof(MapTable), "OnWrite")]
		private static class MapTable_OnWrite_TrackWriteInProgress
		{
			internal static bool isWriteInProgress;

			private const float ForcedCheckDebounceSeconds = 5f;

			private static float lastForcedCheckTime = float.NegativeInfinity;

			private static void Prefix()
			{
				isWriteInProgress = true;
			}

			private static void Postfix()
			{
				isWriteInProgress = false;
				if (!string.IsNullOrEmpty(snapshotUrl.Value) && (!onlyInNoMapMode.Value || Game.m_noMap) && !(Time.realtimeSinceStartup - lastForcedCheckTime < 5f))
				{
					lastForcedCheckTime = Time.realtimeSinceStartup;
					((MonoBehaviour)instance).StartCoroutine(SnapshotViewer.RefreshInBackground(snapshotUrl.Value, snapshotKey.Value, requestTimeoutSeconds.Value, forceTileCheck: true));
				}
			}
		}

		[HarmonyPatch(typeof(MapTable), "OnRead", new Type[]
		{
			typeof(Switch),
			typeof(Humanoid),
			typeof(ItemData),
			typeof(bool)
		})]
		private static class MapTable_OnRead_ShowSnapshot
		{
			private static void Postfix(MapTable __instance, ItemData item)
			{
				//IL_0038: 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)
				if (item == null && !MapTable_OnWrite_TrackWriteInProgress.isWriteInProgress && !string.IsNullOrEmpty(snapshotUrl.Value) && (!onlyInNoMapMode.Value || Game.m_noMap) && PrivateArea.CheckAccess(((Component)__instance).transform.position, 0f, true, false))
				{
					((MonoBehaviour)instance).StartCoroutine(SnapshotViewer.ShowSnapshot(snapshotUrl.Value, snapshotKey.Value, requestTimeoutSeconds.Value, showPlayerMarker.Value, ((Component)__instance).transform.position, autoCloseDistance.Value));
				}
			}
		}

		private const string PluginGUID = "com.snakesquad.cartographysnapshot";

		private const string PluginName = "SnakeSquad Cartography Snapshot";

		private const string PluginVersion = "1.17.1";

		internal static ConfigEntry<string> snapshotUrl;

		internal static ConfigEntry<string> snapshotKey;

		internal static ConfigEntry<string> accessClientId;

		internal static ConfigEntry<string> accessClientSecret;

		internal static ConfigEntry<bool> onlyInNoMapMode;

		internal static ConfigEntry<int> requestTimeoutSeconds;

		internal static ConfigEntry<bool> showPlayerMarker;

		internal static ConfigEntry<bool> verboseTileLogging;

		internal static ConfigEntry<float> autoCloseDistance;

		internal static ConfigEntry<bool> downloadOnStartup;

		private static CartographySnapshotPlugin instance;

		internal static MonoBehaviour CoroutineHost => (MonoBehaviour)(object)instance;

		private void Awake()
		{
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			instance = this;
			snapshotUrl = ((BaseUnityPlugin)this).Config.Bind<string>("1 - General", "Snapshot URL", "https://draw.snakesquad.net/valheim-snapshot.png", "URL to fetch a PNG from when a Cartography Table is read. Leave empty to disable this plugin's behavior entirely.");
			snapshotKey = ((BaseUnityPlugin)this).Config.Bind<string>("1 - General", "Snapshot Key", "", "Shared secret sent as the X-Snapshot-Key request header. Get this from whoever runs the snapshot service. If left empty, it's filled in on the next launch from the snapshot-credentials.txt installed alongside the mod (the SnakeTography package includes one).");
			accessClientId = ((BaseUnityPlugin)this).Config.Bind<string>("1 - General", "Access Client Id", "", "Cloudflare Access service-token id, sent as the CF-Access-Client-Id header - the snapshot service sits behind Cloudflare Access, which turns away requests without it. Filled in from snapshot-credentials.txt like the Snapshot Key.");
			accessClientSecret = ((BaseUnityPlugin)this).Config.Bind<string>("1 - General", "Access Client Secret", "", "Cloudflare Access service-token secret, sent as the CF-Access-Client-Secret header. Filled in from snapshot-credentials.txt like the Snapshot Key.");
			onlyInNoMapMode = ((BaseUnityPlugin)this).Config.Bind<bool>("1 - General", "Only In No Map Mode", true, "If on, the snapshot only replaces the Cartography Table's (otherwise do-nothing) behavior when the server's 'No Map' setting is active. If off, it always shows the snapshot.");
			requestTimeoutSeconds = ((BaseUnityPlugin)this).Config.Bind<int>("1 - General", "Request Timeout Seconds", 15, "How long to wait for the snapshot image to download before giving up.");
			showPlayerMarker = ((BaseUnityPlugin)this).Config.Bind<bool>("1 - General", "Show Player Marker", true, "If on, draws a dot on the snapshot at your current position, using the geometry headers the snapshot service returns. If those headers are missing from a response, no marker is drawn regardless of this setting.");
			verboseTileLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("2 - Debugging", "Verbose Tile Logging", false, "If on, logs detailed info about each map tile download to LogOutput.log (status, timing, size, error text) - useful for diagnosing tile-loading issues. Off by default to avoid log spam during normal play.");
			autoCloseDistance = ((BaseUnityPlugin)this).Config.Bind<float>("1 - General", "Auto-Close Distance", 10f, "If you walk more than this many meters from the Cartography Table while the snapshot is open, it closes automatically - typical crafting-station behavior.");
			downloadOnStartup = ((BaseUnityPlugin)this).Config.Bind<bool>("1 - General", "Download Map Detail On Startup", true, "If on, checks the map and starts downloading any missing or outdated sharp-zoom tiles as soon as the game launches, in the background, so they're ready before you reach a Cartography Table. If off, that only starts when a table is used.");
			((BaseUnityPlugin)this).Config.Bind<bool>("1 - General", "Reload Config From Disk", false, new ConfigDescription("Click to reload this plugin's settings from the .cfg file on disk immediately, without restarting Valheim - for after hand-editing Snapshot Key/URL.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					CustomDrawer = DrawReloadConfigButton
				}
			}));
			ApplyBundledCredentials();
			Harmony val = new Harmony("com.snakesquad.cartographysnapshot");
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(Assembly.GetExecutingAssembly());
			foreach (Type type in typesFromAssembly)
			{
				try
				{
					val.CreateClassProcessor(type).Patch();
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Couldn't apply patch " + type.Name + " (a game update may have changed what it hooks) - that part of the plugin is disabled: " + ex.Message));
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Patched: " + string.Join(", ", from m in val.GetPatchedMethods()
				select m.DeclaringType?.Name + "." + m.Name)));
			if (downloadOnStartup.Value && !string.IsNullOrEmpty(snapshotUrl.Value))
			{
				((MonoBehaviour)this).StartCoroutine(SnapshotViewer.RefreshInBackground(snapshotUrl.Value, snapshotKey.Value, requestTimeoutSeconds.Value));
			}
		}

		private void ApplyBundledCredentials()
		{
			string path = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? "";
			try
			{
				string path2 = Path.Combine(path, "snapshot-credentials.txt");
				if (File.Exists(path2))
				{
					string[] array = File.ReadAllLines(path2);
					foreach (string text in array)
					{
						int num = text.IndexOf('=');
						if (num > 0 && !text.TrimStart(Array.Empty<char>()).StartsWith("#"))
						{
							string text2 = text.Substring(0, num).Trim();
							string value = text.Substring(num + 1).Trim();
							FillIfEmpty((ConfigEntry<string>?)(text2 switch
							{
								"Snapshot Key" => snapshotKey, 
								"Access Client Id" => accessClientId, 
								"Access Client Secret" => accessClientSecret, 
								_ => null, 
							}), value, "snapshot-credentials.txt");
						}
					}
				}
				string path3 = Path.Combine(path, "snapshot-key.txt");
				if (File.Exists(path3))
				{
					FillIfEmpty(snapshotKey, File.ReadAllText(path3).Trim(), "snapshot-key.txt");
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Couldn't read the bundled credentials file: " + ex.Message));
			}
		}

		private void FillIfEmpty(ConfigEntry<string>? entry, string value, string source)
		{
			if (entry != null && value.Length != 0 && string.IsNullOrEmpty(entry.Value))
			{
				entry.Value = value;
				((BaseUnityPlugin)this).Logger.LogInfo((object)(((ConfigEntryBase)entry).Definition.Key + " was empty - filled it in from the " + source + " installed with the mod."));
			}
		}

		internal static void PrepareSnapshotRequest(UnityWebRequest request, string key)
		{
			request.redirectLimit = 0;
			SetHeaderIfPresent(request, "X-Snapshot-Key", key);
			SetHeaderIfPresent(request, "CF-Access-Client-Id", accessClientId.Value);
			SetHeaderIfPresent(request, "CF-Access-Client-Secret", accessClientSecret.Value);
		}

		private static void SetHeaderIfPresent(UnityWebRequest request, string name, string? value)
		{
			if (!string.IsNullOrEmpty(value))
			{
				request.SetRequestHeader(name, value.Trim());
			}
		}

		internal static bool IsAccessDenied(UnityWebRequest request)
		{
			switch (request.responseCode)
			{
			default:
				return (request.error?.IndexOf("redirect", StringComparison.OrdinalIgnoreCase) ?? (-1)) >= 0;
			case 300L:
			case 301L:
			case 302L:
			case 303L:
			case 305L:
			case 306L:
			case 307L:
			case 308L:
			case 309L:
			case 310L:
			case 311L:
			case 312L:
			case 313L:
			case 314L:
			case 315L:
			case 316L:
			case 317L:
			case 318L:
			case 319L:
			case 320L:
			case 321L:
			case 322L:
			case 323L:
			case 324L:
			case 325L:
			case 326L:
			case 327L:
			case 328L:
			case 329L:
			case 330L:
			case 331L:
			case 332L:
			case 333L:
			case 334L:
			case 335L:
			case 336L:
			case 337L:
			case 338L:
			case 339L:
			case 340L:
			case 341L:
			case 342L:
			case 343L:
			case 344L:
			case 345L:
			case 346L:
			case 347L:
			case 348L:
			case 349L:
			case 350L:
			case 351L:
			case 352L:
			case 353L:
			case 354L:
			case 355L:
			case 356L:
			case 357L:
			case 358L:
			case 359L:
			case 360L:
			case 361L:
			case 362L:
			case 363L:
			case 364L:
			case 365L:
			case 366L:
			case 367L:
			case 368L:
			case 369L:
			case 370L:
			case 371L:
			case 372L:
			case 373L:
			case 374L:
			case 375L:
			case 376L:
			case 377L:
			case 378L:
			case 379L:
			case 380L:
			case 381L:
			case 382L:
			case 383L:
			case 384L:
			case 385L:
			case 386L:
			case 387L:
			case 388L:
			case 389L:
			case 390L:
			case 391L:
			case 392L:
			case 393L:
			case 394L:
			case 395L:
			case 396L:
			case 397L:
			case 398L:
			case 399L:
			case 403L:
				return true;
			}
		}

		internal static string AccessDeniedMessage(UnityWebRequest request)
		{
			return $"Cloudflare Access turned the request away (HTTP {request.responseCode}) - access token missing or wrong: check Access Client Id and Access Client Secret.";
		}

		private static void DrawReloadConfigButton(ConfigEntryBase _)
		{
			if (GUILayout.Button("Reload now", Array.Empty<GUILayoutOption>()))
			{
				((BaseUnityPlugin)instance).Config.Reload();
				((BaseUnityPlugin)instance).Logger.LogInfo((object)"Config reloaded from disk.");
			}
		}
	}
	internal static class SnapshotViewer
	{
		private readonly struct SnapshotContext
		{
			public readonly string Url;

			public readonly string Key;

			public readonly int TimeoutSeconds;

			public readonly bool HasGeometry;

			public readonly float PixelsPerUnit;

			public readonly float LeftX;

			public readonly float TopZ;

			public readonly Vector3 TablePosition;

			public readonly float AutoCloseDistance;

			public SnapshotContext(string url, string key, int timeoutSeconds, bool hasGeometry, float pixelsPerUnit, float leftX, float topZ, Vector3 tablePosition, float autoCloseDistance)
			{
				//IL_0036: 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)
				Url = url;
				Key = key;
				TimeoutSeconds = timeoutSeconds;
				HasGeometry = hasGeometry;
				PixelsPerUnit = pixelsPerUnit;
				LeftX = leftX;
				TopZ = topZ;
				TablePosition = tablePosition;
				AutoCloseDistance = autoCloseDistance;
			}
		}

		private class CloseOnInput : MonoBehaviour
		{
			private void Update()
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					escapeCloseFrame = Time.frameCount;
					Close();
				}
				else if (Input.GetKeyDown((KeyCode)101))
				{
					Close();
				}
			}
		}

		private class PanZoom : MonoBehaviour
		{
			private const float MinZoom = 1f;

			private const float MaxZoom = 8f;

			private const float ZoomPerScrollNotch = 0.5f;

			private const float ClickMovementThreshold = 6f;

			private const float MagnificationBeforeNextLevel = 1.15f;

			private const float VisibleMarginFraction = 0.1f;

			private const float StatusRefreshSeconds = 0.5f;

			private RectTransform mapRect;

			private RectTransform viewportRect;

			private Vector2 fitSize;

			private float zoom = 1f;

			private bool dragging;

			private Vector3 lastMousePosition;

			private Vector3 mouseDownPosition;

			private Canvas canvas;

			private Texture2D overviewTexture;

			private bool hasGeometry;

			private float pixelsPerUnit;

			private float leftX;

			private float topZ;

			private Vector3 tablePosition;

			private float autoCloseDistance;

			private readonly RectTransform?[] layers = (RectTransform?[])(object)new RectTransform[TileCache.Levels.Length];

			private readonly Dictionary<string, RawImage> tileImages = new Dictionary<string, RawImage>();

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

			private readonly List<TileCache.Cell> cellsBuffer = new List<TileCache.Cell>();

			private readonly List<TileCache.Cell> wantedCells = new List<TileCache.Cell>();

			private bool tilesDirty = true;

			private float nextStatusRefresh;

			private TextMeshProUGUI? loadingText;

			private bool refreshingTiles;

			public void Initialize(RectTransform map, RectTransform viewport, Vector2 baseFitSize)
			{
				//IL_000f: 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)
				mapRect = map;
				viewportRect = viewport;
				fitSize = baseFitSize;
			}

			public void InitializeTiles(Texture2D texture, SnapshotContext context)
			{
				//IL_0039: 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)
				overviewTexture = texture;
				hasGeometry = context.HasGeometry;
				pixelsPerUnit = context.PixelsPerUnit;
				leftX = context.LeftX;
				topZ = context.TopZ;
				tablePosition = context.TablePosition;
				autoCloseDistance = context.AutoCloseDistance;
			}

			private void Awake()
			{
				canvas = ((Component)this).GetComponent<Canvas>();
			}

			private void Start()
			{
				//IL_002a: 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_003a: Expected O, but got Unknown
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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 i = 0; i < layers.Length; i++)
				{
					RectTransform val = (RectTransform)new GameObject($"TileLayer{i}", new Type[1] { typeof(RectTransform) }).transform;
					((Transform)val).SetParent((Transform)(object)mapRect, false);
					((Transform)val).SetSiblingIndex(i);
					val.anchorMin = Vector2.zero;
					val.anchorMax = Vector2.one;
					val.offsetMin = Vector2.zero;
					val.offsetMax = Vector2.zero;
					layers[i] = val;
				}
				TileCache.TexturesChanged += OnTexturesChanged;
				((MonoBehaviour)this).StartCoroutine(KeepCursorFree());
			}

			private IEnumerator KeepCursorFree()
			{
				WaitForEndOfFrame waitForEndOfFrame = new WaitForEndOfFrame();
				while (true)
				{
					yield return waitForEndOfFrame;
					Cursor.lockState = (CursorLockMode)0;
					Cursor.visible = true;
				}
			}

			private void OnDestroy()
			{
				TileCache.TexturesChanged -= OnTexturesChanged;
				TileCache.SetWanted(new List<TileCache.Cell>());
			}

			private void OnTexturesChanged()
			{
				if ((Object)(object)layers[0] != (Object)null)
				{
					RefreshTiles();
				}
			}

			private void Update()
			{
				//IL_0033: 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_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//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_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: 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_0117: 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)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: 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_0198: 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_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: 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_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer != (Object)null && Vector3.Distance(((Component)localPlayer).transform.position, tablePosition) > autoCloseDistance)
				{
					Close();
					return;
				}
				float y = Input.mouseScrollDelta.y;
				if (y != 0f)
				{
					float num = Mathf.Clamp(zoom + y * 0.5f, 1f, 8f);
					if (num != zoom)
					{
						zoom = num;
						mapRect.sizeDelta = fitSize * zoom;
						ClampPosition();
						tilesDirty = true;
					}
				}
				if (Input.GetMouseButtonDown(0))
				{
					dragging = true;
					lastMousePosition = Input.mousePosition;
					mouseDownPosition = Input.mousePosition;
				}
				else if (Input.GetMouseButtonUp(0))
				{
					dragging = false;
					if (Vector3.Distance(Input.mousePosition, mouseDownPosition) < 6f)
					{
						Close();
						return;
					}
				}
				if (dragging && Input.GetMouseButton(0))
				{
					Vector3 val = Input.mousePosition - lastMousePosition;
					lastMousePosition = Input.mousePosition;
					if (val != Vector3.zero)
					{
						Vector2 anchoredPosition = mapRect.anchoredPosition;
						RectTransform obj = mapRect;
						obj.anchoredPosition += Vector2.op_Implicit(val);
						ClampPosition();
						tilesDirty |= mapRect.anchoredPosition != anchoredPosition;
					}
				}
				if (Input.GetKeyDown((KeyCode)114) && (zoom != 1f || mapRect.anchoredPosition != Vector2.zero))
				{
					zoom = 1f;
					mapRect.sizeDelta = fitSize;
					mapRect.anchoredPosition = Vector2.zero;
					tilesDirty = true;
				}
				if (tilesDirty || Time.unscaledTime >= nextStatusRefresh)
				{
					RefreshTiles();
				}
			}

			private void ClampPosition()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//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)
				//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_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)
				//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_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_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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_0072: 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)
				Vector2 sizeDelta = mapRect.sizeDelta;
				Rect rect = viewportRect.rect;
				Vector2 val = Vector2.Max((sizeDelta - ((Rect)(ref rect)).size) * 0.5f, Vector2.zero);
				Vector2 anchoredPosition = mapRect.anchoredPosition;
				anchoredPosition.x = Mathf.Clamp(anchoredPosition.x, 0f - val.x, val.x);
				anchoredPosition.y = Mathf.Clamp(anchoredPosition.y, 0f - val.y, val.y);
				mapRect.anchoredPosition = anchoredPosition;
			}

			private void RefreshTiles()
			{
				if (refreshingTiles)
				{
					tilesDirty = true;
					return;
				}
				refreshingTiles = true;
				try
				{
					RefreshTilesCore();
				}
				finally
				{
					refreshingTiles = false;
				}
			}

			private void RefreshTilesCore()
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				tilesDirty = false;
				nextStatusRefresh = Time.unscaledTime + 0.5f;
				if (!hasGeometry || (Object)(object)layers[0] == (Object)null)
				{
					return;
				}
				float num = ((Texture)overviewTexture).width;
				_ = ((Texture)overviewTexture).height;
				float num2 = num / pixelsPerUnit;
				float num3 = mapRect.sizeDelta.x * canvas.scaleFactor / num2;
				int num4 = -1;
				float num5 = pixelsPerUnit;
				TileCache.Level[] levels = TileCache.Levels;
				foreach (TileCache.Level level in levels)
				{
					if (num3 <= num5 * 1.15f)
					{
						break;
					}
					num4 = level.Index;
					num5 = level.PixelsPerUnit;
				}
				visibleKeys.Clear();
				wantedCells.Clear();
				bool flag = false;
				if (num4 >= 0 && TryGetVisibleWorldRect(out var x, out var x2, out var z, out var z2))
				{
					float num6 = (x2 - x) * 0.1f;
					float num7 = (z2 - z) * 0.1f;
					for (int j = 0; j <= num4; j++)
					{
						TileCache.CellsIntersecting(TileCache.Levels[j], x - num6, x2 + num6, z - num7, z2 + num7, cellsBuffer);
						foreach (TileCache.Cell item in cellsBuffer)
						{
							wantedCells.Add(item);
							Texture2D texture = TileCache.GetTexture(item);
							if ((Object)(object)texture == (Object)null)
							{
								flag |= j == num4 && !TileCache.IsKnownEmpty(item);
								continue;
							}
							visibleKeys.Add(item.Key);
							ShowTile(item, texture, layers[j]);
						}
					}
				}
				foreach (KeyValuePair<string, RawImage> tileImage in tileImages)
				{
					if (!visibleKeys.Contains(tileImage.Key) && ((Component)tileImage.Value).gameObject.activeSelf)
					{
						((Component)tileImage.Value).gameObject.SetActive(false);
					}
				}
				TileCache.SetWanted(wantedCells);
				UpdateStatus(flag && (TileCache.IsSyncing || TileCache.IsLoadingFromDisk));
			}

			private void ShowTile(TileCache.Cell cell, Texture2D texture, RectTransform layer)
			{
				//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)
				//IL_0058: 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_0099: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				if (!tileImages.TryGetValue(cell.Key, out RawImage value))
				{
					GameObject val = new GameObject(cell.Key);
					val.transform.SetParent((Transform)(object)layer, false);
					value = val.AddComponent<RawImage>();
					((Graphic)value).raycastTarget = false;
					float num = ((Texture)overviewTexture).width;
					float num2 = ((Texture)overviewTexture).height;
					Rect worldRect = cell.WorldRect;
					RectTransform rectTransform = ((Graphic)value).rectTransform;
					rectTransform.anchorMin = new Vector2((((Rect)(ref worldRect)).xMin - leftX) * pixelsPerUnit / num, 1f - (topZ - ((Rect)(ref worldRect)).yMin) * pixelsPerUnit / num2);
					rectTransform.anchorMax = new Vector2((((Rect)(ref worldRect)).xMax - leftX) * pixelsPerUnit / num, 1f - (topZ - ((Rect)(ref worldRect)).yMax) * pixelsPerUnit / num2);
					rectTransform.offsetMin = Vector2.zero;
					rectTransform.offsetMax = Vector2.zero;
					tileImages[cell.Key] = value;
				}
				if ((Object)(object)value.texture != (Object)(object)texture)
				{
					value.texture = (Texture)(object)texture;
				}
				if (!((Component)value).gameObject.activeSelf)
				{
					((Component)value).gameObject.SetActive(true);
				}
			}

			private bool TryGetVisibleWorldRect(out float x0, out float x1, out float z0, out float z1)
			{
				//IL_0006: 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_0015: 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_0021: 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_002f: 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_003b: 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_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: 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_005c: 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_0079: 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_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = mapRect.sizeDelta * 0.5f;
				Rect rect = viewportRect.rect;
				Vector2 val2 = ((Rect)(ref rect)).size * 0.5f;
				Vector2 anchoredPosition = mapRect.anchoredPosition;
				float num = anchoredPosition.x - val.x;
				float num2 = anchoredPosition.y + val.y;
				float num3 = val.x * 2f;
				float num4 = val.y * 2f;
				float num5 = Mathf.Max(num, 0f - val2.x);
				float num6 = Mathf.Min(anchoredPosition.x + val.x, val2.x);
				float num7 = Mathf.Min(num2, val2.y);
				float num8 = Mathf.Max(anchoredPosition.y - val.y, 0f - val2.y);
				float num9 = (float)((Texture)overviewTexture).width / pixelsPerUnit;
				float num10 = (float)((Texture)overviewTexture).height / pixelsPerUnit;
				x0 = leftX + (num5 - num) / num3 * num9;
				x1 = leftX + (num6 - num) / num3 * num9;
				z1 = topZ - (num2 - num7) / num4 * num10;
				z0 = topZ - (num2 - num8) / num4 * num10;
				if (x1 > x0)
				{
					return z1 > z0;
				}
				return false;
			}

			private void UpdateStatus(bool waitingForTilesInView)
			{
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Expected O, but got Unknown
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: 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_0156: 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)
				string text = "";
				if (waitingForTilesInView)
				{
					text = "Loading sharper view...";
				}
				if (TileCache.IsSyncing && TileCache.SyncTotal > 0)
				{
					text = text + ((text.Length > 0) ? "   " : "") + $"Downloading map detail: {TileCache.SyncDone}/{TileCache.SyncTotal}";
				}
				if (text.Length == 0)
				{
					if ((Object)(object)loadingText != (Object)null)
					{
						((Component)loadingText).gameObject.SetActive(false);
					}
					return;
				}
				if ((Object)(object)loadingText == (Object)null)
				{
					GameObject val = new GameObject("TileLoading");
					val.transform.SetParent(((Component)this).transform, false);
					val.SetActive(false);
					loadingText = val.AddComponent<TextMeshProUGUI>();
					TMP_FontAsset val2 = FindGameFontAsset();
					if ((Object)(object)val2 != (Object)null)
					{
						((TMP_Text)loadingText).font = val2;
					}
					((TMP_Text)loadingText).alignment = (TextAlignmentOptions)514;
					((TMP_Text)loadingText).fontSize = 18f;
					((Graphic)loadingText).color = new Color(1f, 1f, 1f, 0.85f);
					RectTransform rectTransform = ((TMP_Text)loadingText).rectTransform;
					rectTransform.anchorMin = new Vector2(0f, 0.95f);
					rectTransform.anchorMax = new Vector2(1f, 1f);
					rectTransform.offsetMin = Vector2.zero;
					rectTransform.offsetMax = Vector2.zero;
				}
				((TMP_Text)loadingText).text = text;
				((Component)loadingText).gameObject.SetActive(true);
			}
		}

		private static readonly ManualLogSource logger = Logger.CreateLogSource("SnakeSquadCartographySnapshot");

		private static GameObject? overlay;

		private static bool isFetching;

		private static CursorLockMode previousCursorLockState;

		private static bool previousCursorVisible;

		private static string? displayedUrl;

		private static bool displayedShowPlayerMarker;

		private static Vector3 displayedTablePosition;

		private static float displayedAutoCloseDistance;

		private static string? cachedUrl;

		private static string? cachedETag;

		private static Texture2D? cachedTexture;

		private static bool cachedHasGeometry;

		private static float cachedPixelsPerUnit;

		private static float cachedLeftX;

		private static float cachedTopZ;

		private static TMP_FontAsset? cachedFontAsset;

		private static bool blockUntilMouseReleased;

		private static int escapeCloseFrame = -1;

		public static bool IsOpen => (Object)(object)overlay != (Object)null;

		public static bool ShouldBlockPlayerActions
		{
			get
			{
				if ((Object)(object)overlay != (Object)null)
				{
					return true;
				}
				if (blockUntilMouseReleased && !Input.GetMouseButton(0) && !Input.GetMouseButton(1))
				{
					blockUntilMouseReleased = false;
				}
				return blockUntilMouseReleased;
			}
		}

		public static bool ShouldSuppressGameMenu
		{
			get
			{
				if (!((Object)(object)overlay != (Object)null))
				{
					return Time.frameCount == escapeCloseFrame;
				}
				return true;
			}
		}

		public static IEnumerator ShowSnapshot(string url, string key, int timeoutSeconds, bool showPlayerMarker, Vector3 tablePosition, float autoCloseDistance)
		{
			//IL_0023: 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)
			if (!((Object)(object)overlay != (Object)null))
			{
				if ((Object)(object)cachedTexture == (Object)null || cachedUrl != url)
				{
					yield return FetchAndCache(url, key, timeoutSeconds, silent: false);
				}
				if ((Object)(object)overlay == (Object)null && (Object)(object)cachedTexture != (Object)null && cachedUrl == url)
				{
					Display(cachedTexture, showPlayerMarker ? TryGetCachedPlayerMarkerFraction(cachedTexture) : ((Vector2?)null), new SnapshotContext(url, key, timeoutSeconds, cachedHasGeometry, cachedPixelsPerUnit, cachedLeftX, cachedTopZ, tablePosition, autoCloseDistance), showPlayerMarker);
				}
				if (cachedUrl == url)
				{
					SyncTiles(key, timeoutSeconds);
				}
			}
		}

		private static void SyncTiles(string key, int timeoutSeconds, bool force = false)
		{
			if ((Object)(object)cachedTexture != (Object)null && cachedHasGeometry && cachedUrl != null)
			{
				TileCache.EnsureSynced(cachedUrl, key, timeoutSeconds, cachedETag, cachedLeftX, cachedTopZ, cachedPixelsPerUnit, ((Texture)cachedTexture).width, ((Texture)cachedTexture).height, force);
			}
			else if (force)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, "Couldn't check the map right now.", 0, (Sprite)null, false);
				}
			}
		}

		public static IEnumerator RefreshInBackground(string url, string key, int timeoutSeconds, bool forceTileCheck = false)
		{
			yield return FetchAndCache(url, key, timeoutSeconds, silent: true);
			if (!forceTileCheck)
			{
				yield break;
			}
			if (cachedUrl == url)
			{
				SyncTiles(key, timeoutSeconds, force: true);
				yield break;
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, "Couldn't check the map right now.", 0, (Sprite)null, false);
			}
		}

		private static IEnumerator FetchAndCache(string url, string key, int timeoutSeconds, bool silent)
		{
			if (isFetching)
			{
				yield break;
			}
			isFetching = true;
			UnityWebRequest request = UnityWebRequestTexture.GetTexture(url);
			try
			{
				request.timeout = timeoutSeconds;
				CartographySnapshotPlugin.PrepareSnapshotRequest(request, key);
				if (url == cachedUrl && !string.IsNullOrEmpty(cachedETag))
				{
					request.SetRequestHeader("If-None-Match", cachedETag);
				}
				yield return request.SendWebRequest();
				isFetching = false;
				if (CartographySnapshotPlugin.IsAccessDenied(request))
				{
					ReportFetchProblem(silent, CartographySnapshotPlugin.AccessDeniedMessage(request), "Map access token is missing or wrong (check the mod's config).");
					yield break;
				}
				if (request.responseCode == 0L)
				{
					ReportFetchProblem(silent, "Failed to reach " + url + ": " + request.error, "Could not reach the map server.");
					yield break;
				}
				switch (request.responseCode)
				{
				case 200L:
				{
					if ((int)request.result != 1)
					{
						ReportFetchProblem(silent, $"Snapshot request to {url} returned 200 but the response body wasn't a usable image ({request.result}).", "Could not load the map.");
						break;
					}
					Texture2D content = DownloadHandlerTexture.GetContent(request);
					float value = 0f;
					float value2 = 0f;
					float value3 = 0f;
					bool num = TryGetFloatHeader(request, "X-Snapshot-Pixels-Per-Unit", out value) && TryGetFloatHeader(request, "X-Snapshot-Left-X", out value2) && TryGetFloatHeader(request, "X-Snapshot-Top-Z", out value3) && value > 0f;
					if ((Object)(object)cachedTexture != (Object)null && (Object)(object)cachedTexture != (Object)(object)content)
					{
						Object.Destroy((Object)(object)cachedTexture);
					}
					cachedUrl = url;
					cachedETag = request.GetResponseHeader("ETag");
					cachedTexture = content;
					cachedHasGeometry = num;
					cachedPixelsPerUnit = value;
					cachedLeftX = value2;
					cachedTopZ = value3;
					RefreshDisplayedOverlayIfShowing(url, key, timeoutSeconds);
					SyncTiles(key, timeoutSeconds);
					break;
				}
				case 304L:
					if ((Object)(object)cachedTexture == (Object)null || url != cachedUrl)
					{
						ReportFetchProblem(silent, "Snapshot server returned 304 but we have no cached image for this URL.", "Could not load the map.");
						break;
					}
					logger.LogInfo((object)"Snapshot unchanged since last check (304).");
					SyncTiles(key, timeoutSeconds);
					break;
				case 401L:
					ReportFetchProblem(silent, "Snapshot request returned 401 - Snapshot Key is missing or wrong.", "Map snapshot key is missing or wrong (check the mod's config).");
					break;
				case 503L:
				{
					string responseHeader = request.GetResponseHeader("Retry-After");
					logger.LogInfo((object)("Snapshot not ready yet (503), Retry-After: " + (responseHeader ?? "none") + "."));
					if (!silent)
					{
						Player localPlayer = Player.m_localPlayer;
						if (localPlayer != null)
						{
							((Character)localPlayer).Message((MessageType)2, "The map hasn't finished rendering yet - try again shortly.", 0, (Sprite)null, false);
						}
					}
					break;
				}
				default:
					ReportFetchProblem(silent, $"Snapshot request to {url} returned HTTP {request.responseCode}.", "Could not load the map.");
					break;
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private static void ReportFetchProblem(bool silent, string logMessage, string playerMessage)
		{
			if (silent)
			{
				logger.LogInfo((object)("Background refresh: " + logMessage));
				return;
			}
			logger.LogWarning((object)logMessage);
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, playerMessage, 0, (Sprite)null, false);
			}
		}

		private static void RefreshDisplayedOverlayIfShowing(string url, string key, int timeoutSeconds)
		{
			//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_0073: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)overlay == (Object)null) && !(displayedUrl != url) && !((Object)(object)cachedTexture == (Object)null))
			{
				bool flag = displayedShowPlayerMarker;
				Vector3 tablePosition = displayedTablePosition;
				float autoCloseDistance = displayedAutoCloseDistance;
				Close();
				Display(cachedTexture, flag ? TryGetCachedPlayerMarkerFraction(cachedTexture) : ((Vector2?)null), new SnapshotContext(url, key, timeoutSeconds, cachedHasGeometry, cachedPixelsPerUnit, cachedLeftX, cachedTopZ, tablePosition, autoCloseDistance), flag);
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Map updated.", 0, (Sprite)null, false);
				}
			}
		}

		private static Vector2? ComputeMarkerFraction(float pixelsPerUnit, float leftX, float topZ, Texture2D texture)
		{
			//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_0025: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return null;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			float num = (position.x - leftX) * pixelsPerUnit;
			float num2 = (topZ - position.z) * pixelsPerUnit;
			return new Vector2(Mathf.Clamp01(num / (float)((Texture)texture).width), Mathf.Clamp01(num2 / (float)((Texture)texture).height));
		}

		private static Vector2? TryGetCachedPlayerMarkerFraction(Texture2D texture)
		{
			if (!cachedHasGeometry)
			{
				return null;
			}
			return ComputeMarkerFraction(cachedPixelsPerUnit, cachedLeftX, cachedTopZ, texture);
		}

		private static bool TryGetFloatHeader(UnityWebRequest request, string headerName, out float value)
		{
			return float.TryParse(request.GetResponseHeader(headerName), NumberStyles.Float, CultureInfo.InvariantCulture, out value);
		}

		private static void Display(Texture2D texture, Vector2? playerMarkerFraction, SnapshotContext context, bool showPlayerMarker)
		{
			//IL_0012: 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_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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0083: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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_00f9: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			//IL_0196: 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_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: 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_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: 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_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: 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_027e: 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_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			displayedUrl = context.Url;
			displayedShowPlayerMarker = showPlayerMarker;
			displayedTablePosition = context.TablePosition;
			displayedAutoCloseDistance = context.AutoCloseDistance;
			previousCursorLockState = Cursor.lockState;
			previousCursorVisible = Cursor.visible;
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			GameObject val = new GameObject("SnakeSquadCartographySnapshotCanvas");
			Canvas obj = val.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 32767;
			val.AddComponent<CanvasScaler>();
			val.AddComponent<GraphicRaycaster>();
			val.AddComponent<CloseOnInput>();
			GameObject val2 = new GameObject("Background");
			val2.transform.SetParent(val.transform, false);
			Image obj2 = val2.AddComponent<Image>();
			((Graphic)obj2).color = new Color(0f, 0f, 0f, 0.85f);
			RectTransform rectTransform = ((Graphic)obj2).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			GameObject val3 = new GameObject("Viewport");
			val3.transform.SetParent(val.transform, false);
			val3.AddComponent<RectMask2D>();
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.05f, 0.08f);
			component.anchorMax = new Vector2(0.95f, 0.95f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			GameObject val4 = new GameObject("Map");
			val4.transform.SetParent(val3.transform, false);
			RawImage obj3 = val4.AddComponent<RawImage>();
			obj3.texture = (Texture)(object)texture;
			RectTransform rectTransform2 = ((Graphic)obj3).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = Vector2.zero;
			Rect rect = component.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			float num = (float)((Texture)texture).width / (float)((Texture)texture).height;
			float num2 = size.x / size.y;
			Vector2 baseFitSize = (rectTransform2.sizeDelta = ((num > num2) ? new Vector2(size.x, size.x / num) : new Vector2(size.y * num, size.y)));
			AddFrame(val4.transform);
			if (playerMarkerFraction.HasValue)
			{
				Vector2 valueOrDefault = playerMarkerFraction.GetValueOrDefault();
				AddPlayerMarker(val4.transform, valueOrDefault);
			}
			PanZoom panZoom = val.AddComponent<PanZoom>();
			panZoom.Initialize(rectTransform2, component, baseFitSize);
			panZoom.InitializeTiles(texture, context);
			AddHintText(val.transform);
			overlay = val;
		}

		private static void AddFrame(Transform imageTransform)
		{
			//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)
			//IL_0037: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0084: 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_0098: 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_00c2: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			Color frameColor = new Color(0.9f, 0.85f, 0.65f, 0.95f);
			AddStrip("FrameTop", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -5f), Vector2.zero);
			AddStrip("FrameBottom", new Vector2(0f, 0f), new Vector2(1f, 0f), Vector2.zero, new Vector2(0f, 5f));
			AddStrip("FrameLeft", new Vector2(0f, 0f), new Vector2(0f, 1f), Vector2.zero, new Vector2(5f, 0f));
			AddStrip("FrameRight", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(-5f, 0f), Vector2.zero);
			void AddStrip(string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
			{
				//IL_0001: 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_0021: 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_003f: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject(name);
				val.transform.SetParent(imageTransform, false);
				Image obj = val.AddComponent<Image>();
				((Graphic)obj).color = frameColor;
				((Graphic)obj).raycastTarget = false;
				RectTransform rectTransform = ((Graphic)obj).rectTransform;
				rectTransform.anchorMin = anchorMin;
				rectTransform.anchorMax = anchorMax;
				rectTransform.offsetMin = offsetMin;
				rectTransform.offsetMax = offsetMax;
			}
		}

		private static void AddPlayerMarker(Transform parent, Vector2 fraction)
		{
			//IL_0002: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0038: 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_004f: 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_0075: 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_008e: 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_00ba: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(fraction.x, 1f - fraction.y);
			GameObject val2 = new GameObject("PlayerMarkerBacking");
			val2.transform.SetParent(parent, false);
			Image obj = val2.AddComponent<Image>();
			((Graphic)obj).color = Color.white;
			RectTransform rectTransform = ((Graphic)obj).rectTransform;
			rectTransform.anchorMin = val;
			rectTransform.anchorMax = val;
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.sizeDelta = new Vector2(16f, 16f);
			rectTransform.anchoredPosition = Vector2.zero;
			GameObject val3 = new GameObject("PlayerMarkerDot");
			val3.transform.SetParent(val2.transform, false);
			Image obj2 = val3.AddComponent<Image>();
			((Graphic)obj2).color = new Color(0.95f, 0.2f, 0.15f);
			RectTransform rectTransform2 = ((Graphic)obj2).rectTransform;
			rectTransform2.anchorMin = Vector2.zero;
			rectTransform2.anchorMax = Vector2.one;
			rectTransform2.offsetMin = new Vector2(3f, 3f);
			rectTransform2.offsetMax = new Vector2(-3f, -3f);
		}

		private static void AddHintText(Transform parent)
		{
			//IL_0005: 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_0017: 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_0047: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Hint");
			val.transform.SetParent(parent, false);
			val.SetActive(false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = "Scroll: zoom   •   Left-drag: pan   •   R: reset view   •   E / Esc / click: close";
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val2).fontSize = 20f;
			((Graphic)val2).color = Color.white;
			TMP_FontAsset val3 = FindGameFontAsset();
			if ((Object)(object)val3 != (Object)null)
			{
				((TMP_Text)val2).font = val3;
			}
			RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0f);
			rectTransform.anchorMax = new Vector2(1f, 0.06f);
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			val.SetActive(true);
		}

		private static TMP_FontAsset? FindGameFontAsset()
		{
			if ((Object)(object)cachedFontAsset != (Object)null)
			{
				return cachedFontAsset;
			}
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			cachedFontAsset = ((array.Length != 0) ? array[0] : null);
			return cachedFontAsset;
		}

		public static void Close()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)overlay != (Object)null)
			{
				Object.Destroy((Object)(object)overlay);
				overlay = null;
				blockUntilMouseReleased = true;
				displayedUrl = null;
				Cursor.lockState = previousCursorLockState;
				Cursor.visible = previousCursorVisible;
			}
		}

		internal static void LogDebug(string message)
		{
			if (CartographySnapshotPlugin.verboseTileLogging.Value)
			{
				logger.LogInfo((object)message);
			}
		}
	}
	internal static class InputBlocker
	{
		[HarmonyPatch(typeof(Player), "SetControls")]
		private static class Player_SetControls_BlockActions
		{
			private static void Prefix(Player __instance, ref bool attack, ref bool attackHold, ref bool secondaryAttack, ref bool secondaryAttackHold, ref bool block, ref bool blockHold, ref bool crouch, ref bool dodge)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && SnapshotViewer.ShouldBlockPlayerActions)
				{
					attack = (attackHold = (secondaryAttack = (secondaryAttackHold = (block = (blockHold = (crouch = (dodge = false)))))));
				}
			}
		}

		[HarmonyPatch]
		private static class Player_SetMouseLook_Freeze
		{
			private static bool Prepare()
			{
				return FindMethod(typeof(Player), "SetMouseLook", (MethodInfo _) => true) != null;
			}

			private static MethodBase TargetMethod()
			{
				return FindMethod(typeof(Player), "SetMouseLook", (MethodInfo _) => true);
			}

			private static bool Prefix(object __instance)
			{
				if (SnapshotViewer.IsOpen)
				{
					return __instance != Player.m_localPlayer;
				}
				return true;
			}
		}

		[HarmonyPatch]
		private static class ZInput_GetMouseDelta_Zero
		{
			private static bool Prepare()
			{
				return FindMethod(typeof(ZInput), "GetMouseDelta", (MethodInfo m) => m.ReturnType == typeof(Vector2)) != null;
			}

			private static MethodBase TargetMethod()
			{
				return FindMethod(typeof(ZInput), "GetMouseDelta", (MethodInfo m) => m.ReturnType == typeof(Vector2));
			}

			private static void Postfix(ref Vector2 __result)
			{
				//IL_0008: 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)
				if (SnapshotViewer.IsOpen)
				{
					__result = Vector2.zero;
				}
			}
		}

		[HarmonyPatch(typeof(ZInput), "GetMouseScrollWheel")]
		private static class ZInput_GetMouseScrollWheel_Zero
		{
			private static void Postfix(ref float __result)
			{
				if (SnapshotViewer.IsOpen)
				{
					__result = 0f;
				}
			}
		}

		[HarmonyPatch]
		private static class Menu_Update_SuppressWhileMapOpen
		{
			private static bool Prepare()
			{
				return FindMethod(typeof(Menu), "Update", (MethodInfo m) => m.GetParameters().Length == 0) != null;
			}

			private static MethodBase TargetMethod()
			{
				return FindMethod(typeof(Menu), "Update", (MethodInfo m) => m.GetParameters().Length == 0);
			}

			private static bool Prefix()
			{
				return !SnapshotViewer.ShouldSuppressGameMenu;
			}
		}

		[HarmonyPatch]
		private static class Menu_Show_SuppressWhileMapOpen
		{
			private static bool Prepare()
			{
				return FindMethod(typeof(Menu), "Show", (MethodInfo m) => m.GetParameters().Length == 0) != null;
			}

			private static MethodBase TargetMethod()
			{
				return FindMethod(typeof(Menu), "Show", (MethodInfo m) => m.GetParameters().Length == 0);
			}

			private static bool Prefix()
			{
				return !SnapshotViewer.ShouldSuppressGameMenu;
			}
		}

		private static MethodInfo? FindMethod(Type type, string name, Func<MethodInfo, bool> predicate)
		{
			return type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == name && !m.IsAbstract && predicate(m));
		}
	}
	internal static class TileCache
	{
		internal sealed class Level
		{
			public readonly int Index;

			public readonly float CellWorldSize;

			public readonly int CellPixels;

			public float PixelsPerUnit => (float)CellPixels / CellWorldSize;

			public Level(int index, float cellWorldSize, int cellPixels)
			{
				Index = index;
				CellWorldSize = cellWorldSize;
				CellPixels = cellPixels;
			}
		}

		internal sealed class Cell
		{
			public readonly string Key;

			public readonly Level Level;

			public readonly Rect WorldRect;

			public readonly string Url;

			public Cell(string key, Level level, Rect worldRect, string url)
			{
				//IL_0015: 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)
				Key = key;
				Level = level;
				WorldRect = worldRect;
				Url = url;
			}
		}

		private sealed class Meta
		{
			public string Url = "";

			public string TileETag = "";

			public string OverviewETag = "";

			public string ContentHash = "";

			public bool IsEmpty => ContentHash == "-";
		}

		private enum FetchOutcome
		{
			Updated,
			Unchanged,
			Rejected,
			AccessDenied,
			Failed
		}

		internal static readonly Level[] Levels = new Level[2]
		{
			new Level(0, 2048f, 512),
			new Level(1, 1024f, 512)
		};

		private const string EmptyHash = "-";

		private static Dictionary<string, string>? manifest;

		private const float MinCellWorldSide = 10f;

		private const int MinTimeoutSeconds = 30;

		private const int MaxAttempts = 4;

		private const float DefaultRetryDelaySeconds = 2f;

		private const int MaxConsecutiveFailures = 8;

		private const int MinTilePixelWidth = 64;

		private const int DiskLoadsPerFrame = 2;

		private const int MaxLoadedTextures = 240;

		private static readonly ManualLogSource logger = Logger.CreateLogSource("SnakeSquadCartographySnapshot");

		private static string snapshotUrl = "";

		private static string snapshotKey = "";

		private static int timeoutSeconds;

		private static string overviewETag = "";

		private static float minX;

		private static float maxX;

		private static float minZ;

		private static float maxZ;

		private static int configVersion;

		private static readonly List<Cell> cells = new List<Cell>();

		private static readonly Dictionary<string, Cell> cellsByKey = new Dictionary<string, Cell>();

		private static string? cacheDirectory;

		private static readonly Dictionary<string, Meta> metas = new Dictionary<string, Meta>();

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

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

		private static readonly Dictionary<string, Texture2D> loaded = new Dictionary<string, Texture2D>();

		private static readonly Dictionary<string, int> lastUsedFrame = new Dictionary<string, int>();

		private static readonly Queue<string> diskLoadQueue = new Queue<string>();

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

		private static bool diskLoaderRunning;

		private static bool workerRunning;

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

		private static readonly List<Cell> wanted = new List<Cell>();

		private static bool forceQueued;

		private static int updatedFine;

		private static int updatedCoarse;

		private const int MaxConcurrentFetches = 2;

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

		private static int consecutiveFailures;

		private static bool pauseSync;

		private static bool accessDenied;

		private static readonly Func<Texture2D, byte[], bool>? loadImage = BindLoadImage();

		public static bool IsSyncing => workerRunning;

		public static bool IsLoadingFromDisk => diskLoaderRunning;

		public static int SyncTotal { get; private set; }

		public static int SyncDone { get; private set; }

		public static event Action? TexturesChanged;

		public static void EnsureSynced(string url, string key, int timeout, string? etag, float leftX, float topZ, float pixelsPerUnit, int width, int height, bool force = false)
		{
			if (!(pixelsPerUnit <= 0f) && width > 0 && height > 0)
			{
				Configure(url, key, timeout, etag ?? "", leftX, leftX + (float)width / pixelsPerUnit, topZ - (float)height / pixelsPerUnit, topZ);
				if (workerRunning)
				{
					forceQueued |= force;
				}
				else if (force || cells.Any(NeedsFetch))
				{
					CartographySnapshotPlugin.CoroutineHost.StartCoroutine(Worker(force));
				}
			}
		}

		private static void Configure(string url, string key, int timeout, string etag, float newMinX, float newMaxX, float newMinZ, float newMaxZ)
		{
			snapshotKey = key;
			timeoutSeconds = timeout;
			overviewETag = etag;
			if (!(url == snapshotUrl) || newMinX != minX || newMaxX != maxX || newMinZ != minZ || newMaxZ != maxZ)
			{
				if (url != snapshotUrl)
				{
					SetCacheDirectory(url);
				}
				snapshotUrl = url;
				minX = newMinX;
				maxX = newMaxX;
				minZ = newMinZ;
				maxZ = newMaxZ;
				configVersion++;
				BuildCells();
			}
		}

		private static void BuildCells()
		{
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			cells.Clear();
			cellsByKey.Clear();
			string text = (snapshotUrl.Contains("?") ? "&" : "?");
			Level[] levels = Levels;
			foreach (Level level in levels)
			{
				float cellWorldSize = level.CellWorldSize;
				int num = Mathf.FloorToInt(minX / cellWorldSize);
				int num2 = Mathf.CeilToInt(maxX / cellWorldSize) - 1;
				int num3 = Mathf.FloorToInt(minZ / cellWorldSize);
				int num4 = Mathf.CeilToInt(maxZ / cellWorldSize) - 1;
				for (int j = num; j <= num2; j++)
				{
					for (int k = num3; k <= num4; k++)
					{
						float num5 = Mathf.Max((float)j * cellWorldSize, minX);
						float num6 = Mathf.Min((float)(j + 1) * cellWorldSize, maxX);
						float num7 = Mathf.Max((float)k * cellWorldSize, minZ);
						float num8 = Mathf.Min((float)(k + 1) * cellWorldSize, maxZ);
						if (!(num6 - num5 < 10f) && !(num8 - num7 < 10f))
						{
							int num9 = Mathf.Max(64, Mathf.RoundToInt((float)level.CellPixels * (num6 - num5) / cellWorldSize));
							string url = snapshotUrl + text + "x0=" + F(num5) + "&z0=" + F(num8) + "&x1=" + F(num6) + "&z1=" + F(num7) + "&w=" + num9.ToString(CultureInfo.InvariantCulture);
							string key = CellKey(level.Index, j, k);
							Cell cell = new Cell(key, level, new Rect(num5, num7, num6 - num5, num8 - num7), url);
							cells.Add(cell);
							cellsByKey[key] = cell;
						}
					}
				}
			}
			SnapshotViewer.LogDebug($"[MapTile] grid: {cells.Count} tiles over x {F(minX)}..{F(maxX)}, z {F(minZ)}..{F(maxZ)}.");
		}

		private static string CellKey(int level, int ix, int iz)
		{
			return $"L{level}_{ix}_{iz}";
		}

		public static void CellsIntersecting(Level level, float x0, float x1, float z0, float z1, List<Cell> output)
		{
			output.Clear();
			float cellWorldSize = level.CellWorldSize;
			int num = Mathf.FloorToInt(x0 / cellWorldSize);
			int num2 = Mathf.FloorToInt(x1 / cellWorldSize);
			int num3 = Mathf.FloorToInt(z0 / cellWorldSize);
			int num4 = Mathf.FloorToInt(z1 / cellWorldSize);
			for (int i = num; i <= num2; i++)
			{
				for (int j = num3; j <= num4; j++)
				{
					if (cellsByKey.TryGetValue(CellKey(level.Index, i, j), out Cell value))
					{
						output.Add(value);
					}
				}
			}
		}

		public static void SetWanted(List<Cell> cellsInView)
		{
			wanted.Clear();
			wanted.AddRange(cellsInView);
		}

		public static Texture2D? GetTexture(Cell cell)
		{
			lastUsedFrame[cell.Key] = Time.frameCount;
			if (loaded.TryGetValue(cell.Key, out Texture2D value))
			{
				return value;
			}
			if (metas.TryGetValue(cell.Key, out Meta value2) && !value2.IsEmpty && diskLoadPending.Add(cell.Key))
			{
				diskLoadQueue.Enqueue(cell.Key);
				if (!diskLoaderRunning)
				{
					CartographySnapshotPlugin.CoroutineHost.StartCoroutine(DiskLoader());
				}
			}
			return null;
		}

		public static bool IsKnownEmpty(Cell cell)
		{
			if (metas.TryGetValue(cell.Key, out Meta value) && value.IsEmpty)
			{
				return value.Url == cell.Url;
			}
			return false;
		}

		private static bool NeedsFetch(Cell cell)
		{
			if (failedThisPass.Contains(cell.Key) || rejectedThisSession.Contains(cell.Url))
			{
				return false;
			}
			if (!metas.TryGetValue(cell.Key, out Meta value) || value.Url != cell.Url)
			{
				return true;
			}
			if (manifest != null)
			{
				return value.ContentHash != ManifestHash(cell);
			}
			if (overviewETag.Length <= 0)
			{
				return !refreshedThisSession.Contains(cell.Key);
			}
			return value.OverviewETag != overviewETag;
		}

		private static IEnumerator Worker(bool fresh)
		{
			workerRunning = true;
			updatedFine = 0;
			updatedCoarse = 0;
			failedThisPass.Clear();
			inFlight.Clear();
			consecutiveFailures = 0;
			pauseSync = false;
			accessDenied = false;
			int seenConfigVersion = -1;
			List<Cell> ordered = new List<Cell>();
			int orderedIndex = 0;
			SyncDone = 0;
			yield return LoadManifest(fresh);
			pauseSync |= accessDenied;
			while (true)
			{
				if (seenConfigVersion != configVersion)
				{
					ApplyManifest();
					seenConfigVersion = configVersion;
					Vector3 origin = (((Object)(object)Player.m_localPlayer != (Object)null) ? ((Component)Player.m_localPlayer).transform.position : Vector3.zero);
					ordered = (from c in cells.Where(NeedsFetch)
						orderby c.Level.Index
						select c).ThenBy(delegate(Cell c)
					{
						//IL_0001: 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_0009: 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_0029: 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)
						Rect worldRect = c.WorldRect;
						Vector2 val = ((Rect)(ref worldRect)).center - new Vector2(origin.x, origin.z);
						return ((Vector2)(ref val)).sqrMagnitude;
					}).ToList();
					orderedIndex = 0;
					SyncTotal = SyncDone + inFlight.Count + ordered.Count;
					logger.LogInfo((object)$"Map tiles: {ordered.Count} of {cells.Count} need downloading.");
				}
				Cell cell = null;
				if (!pauseSync && inFlight.Count < 2)
				{
					cell = wanted.FirstOrDefault((Cell c) => cellsByKey.TryGetValue(c.Key, out Cell value) && value == c && !inFlight.Contains(c.Key) && NeedsFetch(c));
					if (cell == null)
					{
						for (; orderedIndex < ordered.Count && (inFlight.Contains(ordered[orderedIndex].Key) || !NeedsFetch(ordered[orderedIndex])); orderedIndex++)
						{
						}
						cell = ((orderedIndex < ordered.Count) ? ordered[orderedIndex] : null);
					}
				}
				if (cell != null)
				{
					inFlight.Add(cell.Key);
					CartographySnapshotPlugin.CoroutineHost.StartCoroutine(Lane(cell));
				}
				else if (inFlight.Count == 0 && (pauseSync || orderedIndex >= ordered.Count))
				{
					if (pauseSync || !wanted.Any((Cell c) => cellsByKey.TryGetValue(c.Key, out Cell value) && value == c && NeedsFetch(c)))
					{
						break;
					}
				}
				else
				{
					yield return null;
				}
			}
			if (accessDenied)
			{
				logger.LogWarning((object)"Map tiles: Cloudflare Access turned the requests away - access token missing or wrong: check Access Client Id and Access Client Secret. Stopping until the next time a Cartography Table is used.");
			}
			else if (pauseSync)
			{
				logger.LogWarning((object)$"Map tiles: {8} downloads failed in a row - pausing until the next time a Cartography Table is used.");
			}
			int num = cells.Count((Cell c) => rejectedThisSession.Contains(c.Url));
			if (!accessDenied)
			{
				logger.LogInfo((object)(((failedThisPass.Count == 0) ? "Map tiles: all up to date." : $"Map tiles: done, but {failedThisPass.Count} couldn't be downloaded - they'll be retried the next time a Cartography Table is used.") + ((num > 0) ? $" {num} were refused by the server (see the [MapTile] lines with Verbose Tile Logging on)." : "")));
			}
			if (fresh)
			{
				int num2 = ((updatedFine > 0) ? updatedFine : updatedCoarse);
				string text = (accessDenied ? "Map access token is missing or wrong (check the mod's config)." : ((failedThisPass.Count > 0) ? $"Map update incomplete: {failedThisPass.Count} areas couldn't be downloaded." : ((num2 > 0) ? string.Format("Map updated: {0} {1}.", num2, (num2 == 1) ? "area" : "areas") : "Map up to date.")));
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, text, 0, (Sprite)null, false);
				}
			}
			manifest = null;
			workerRunning = false;
			TileCache.TexturesChanged?.Invoke();
			if (forceQueued)
			{
				forceQueued = false;
				CartographySnapshotPlugin.CoroutineHost.StartCoroutine(Worker(fresh: true));
			}
		}

		private static void CountUpdated(Cell cell)
		{
			if (cell.Level.Index == Levels.Length - 1)
			{
				updatedFine++;
			}
			else
			{
				updatedCoarse++;
			}
		}

		private static IEnumerator Lane(Cell cell)
		{
			FetchOutcome outcome = FetchOutcome.Failed;
			yield return FetchCell(cell, delegate(FetchOutcome result)
			{
				outcome = result;
			});
			inFlight.Remove(cell.Key);
			SyncDone++;
			switch (outcome)
			{
			case FetchOutcome.Updated:
				consecutiveFailures = 0;
				CountUpdated(cell);
				yield break;
			case FetchOutcome.Unchanged:
				consecutiveFailures = 0;
				yield break;
			case FetchOutcome.Rejected:
				rejectedThisSession.Add(cell.Url);
				yield break;
			case FetchOutcome.AccessDenied:
				accessDenied = true;
				pauseSync = true;
				yield break;
			}
			failedThisPass.Add(cell.Key);
			if (++consecutiveFailures >= 8)
			{
				pauseSync = true;
			}
		}

		private static IEnumerator FetchCell(Cell cell, Action<FetchOutcome> done)
		{
			for (int attempt = 1; attempt <= 4; attempt++)
			{
				UnityWebRequest request = UnityWebRequest.Get(cell.Url);
				Meta oldMeta;
				try
				{
					request.timeout = Mathf.Max(timeoutSeconds, 30);
					CartographySnapshotPlugin.PrepareSnapshotRequest(request, snapshotKey);
					if (metas.TryGetValue(cell.Key, out oldMeta) && oldMeta.Url == cell.Url && oldMeta.TileETag.Length > 0)
					{
						request.SetRequestHeader("If-None-Match", oldMeta.TileETag);
					}
					float startTime = Time.realtimeSinceStartup;
					yield return request.SendWebRequest();
					float num = Time.realtimeSinceStartup - startTime;
					long responseCode = request.responseCode;
					object[] obj = new object[7] { cell.Key, attempt, responseCode, request.result, num, null, null };
					DownloadHandler downloadHandler = request.downloadHandler;
					obj[5] = ((downloadHandler == null) ? ((int?)null) : downloadHandler.data?.Length).GetValueOrDefault();
					obj[6] = cell.Url;
					SnapshotViewer.LogDebug(string.Format("[MapTile] {0} attempt {1}: {2} {3} in {4:F1}s ({5} bytes) {6}", obj) + (string.IsNullOrEmpty(request.error) ? "" : (" error=\"" + request.error + "\"")) + ((responseCode >= 400) ? (" body=\"" + ShortBody(request) + "\"") : ""));
					if (CartographySnapshotPlugin.IsAccessDenied(request))
					{
						done(FetchOutcome.AccessDenied);
						yield break;
					}
					if (responseCode == 304 && oldMeta != null)
					{
						oldMeta.OverviewETag = overviewETag;
						oldMeta.ContentHash = ManifestHash(cell) ?? oldMeta.ContentHash;
						SaveMeta(cell.Key, oldMeta);
						refreshedThisSession.Add(cell.Key);
						done(FetchOutcome.Unchanged);
						yield break;
					}
					if (responseCode == 200 && (int)request.result == 1)
					{
						byte[] bytes = request.downloadHandler.data ?? Array.Empty<byte>();
						if (!Store(cell, bytes, request.GetResponseHeader("ETag") ?? ""))
						{
							done(FetchOutcome.Failed);
							yield break;
						}
						refreshedThisSession.Add(cell.Key);
						done(FetchOutcome.Updated);
						yield break;
					}
					if (responseCode >= 400 && responseCode < 500 && responseCode != 401 && responseCode != 408 && responseCode != 429)
					{
						done(FetchOutcome.Rejected);
						yield break;
					}
					if (attempt != 4)
					{
						if ((responseCode == 429 || responseCode == 503) ? true : false)
						{
							float num2 = ParseRetryAfterSeconds(request.GetResponseHeader("Retry-After"));
							SnapshotViewer.LogDebug($"[MapTile] {cell.Key}: HTTP {responseCode}, waiting {num2:F1}s.");
							yield return (object)new WaitForSecondsRealtime(num2);
							continue;
						}
						if (responseCode == 0L && attempt < 2)
						{
							goto IL_044d;
						}
					}
				}
				finally
				{
					((IDisposable)request)?.Dispose();
				}
				break;
				IL_044d:
				oldMeta = null;
			}
			done(FetchOutcome.Failed);
		}

		private static bool Store(Cell cell, byte[] bytes, string tileETag)
		{
			if (!IsPng(bytes))
			{
				SnapshotViewer.LogDebug("[MapTile] " + cell.Key + ": response wasn't a PNG.");
				return false;
			}
			Meta meta = new Meta
			{
				Url = cell.Url,
				TileETag = tileETag,
				OverviewETag = overviewETag,
				ContentHash = (ManifestHash(cell) ?? "")
			};
			try
			{
				if (cacheDirectory != null)
				{
					File.WriteAllBytes(Path.Combine(cacheDirectory, cell.Key + ".png"), bytes);
					SaveMeta(cell.Key, meta);
				}
			}
			catch (Exception ex)
			{
				logger.LogWarning((object)("Couldn't save map tile " + cell.Key + " to disk (it'll still be shown this session): " + ex.Message));
			}
			metas[cell.Key] = meta;
			bool flag = wanted.Any((Cell c) => c.Key == cell.Key);
			if (loaded.TryGetValue(cell.Key, out Texture2D value) || flag)
			{
				Texture2D val = Decode(bytes);
				if ((Object)(object)val == (Object)null)
				{
					SnapshotViewer.LogDebug("[MapTile] " + cell.Key + ": PNG couldn't be decoded.");
					return true;
				}
				loaded[cell.Key] = val;
				TileCache.TexturesChanged?.Invoke();
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				EvictIfNeeded();
			}
			return true;
		}

		private static bool IsPng(byte[] bytes)
		{
			if (bytes.Length > 8 && bytes[0] == 137 && bytes[1] == 80 && bytes[2] == 78)
			{
				return bytes[3] == 71;
			}
			return false;
		}

		private static IEnumerator DiskLoader()
		{
			diskLoaderRunning = true;
			yield return null;
			while (diskLoadQueue.Count > 0)
			{
				for (int i = 0; i < 2; i++)
				{
					if (diskLoadQueue.Count <= 0)
					{
						break;
					}
					string text = diskLoadQueue.Dequeue();
					diskLoadPending.Remove(text);
					if (!loaded.ContainsKey(text) && cacheDirectory != null)
					{
						string path = Path.Combine(cacheDirectory, text + ".png");
						Texture2D val = null;
						try
						{
							val = (File.Exists(path) ? Decode(File.ReadAllBytes(path)) : null);
						}
						catch (Exception ex)
						{
							logger.LogWarning((object)("Couldn't read saved map tile " + text + ": " + ex.Message));
						}
						if ((Object)(object)val == (Object)null)
						{
							metas.Remove(text);
							continue;
						}
						loaded[text] = val;
						TileCache.TexturesChanged?.Invoke();
						EvictIfNeeded();
					}
				}
				yield return null;
			}
			diskLoaderRunning = false;
			TileCache.TexturesChanged?.Invoke();
		}

		private static Func<Texture2D, byte[], bool>? BindLoadImage()
		{
			MethodInfo methodInfo = (Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule") ?? (from a in AppDomain.CurrentDomain.GetAssemblies()
				select a.GetType("UnityEngine.ImageConversion")).FirstOrDefault((Type t) => t != null))?.GetMethod("LoadImage", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
			{
				typeof(Texture2D),
				typeof(byte[])
			}, null);
			if (methodInfo == null)
			{
				logger.LogWarning((object)"UnityEngine.ImageConversion.LoadImage not found - saved map tiles can't be shown.");
				return null;
			}
			return (Func<Texture2D, byte[], bool>)Delegate.CreateDelegate(typeof(Func<Texture2D, byte[], bool>), methodInfo);
		}

		private static Texture2D? Decode(byte[] bytes)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			if (loadImage == null)
			{
				return null;
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true);
			if (!loadImage(val, bytes))
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)2;
			val.Apply(true, false);
			if (((Texture)val).width % 4 == 0 && ((Texture)val).height % 4 == 0)
			{
				val.Compress(false);
			}
			val.Apply(false, true);
			return val;
		}

		private static void EvictIfNeeded()
		{
			if (loaded.Count <= 240)
			{
				return;
			}
			int recentFrame = Time.frameCount - 2;
			int value;
			foreach (string item in (from k in loaded.Keys
				where !lastUsedFrame.TryGetValue(k, out value) || value < recentFrame
				orderby lastUsedFrame.TryGetValue(k, out value) ? value : 0
				select k).Take(loaded.Count - 240).ToList())
			{
				Object.Destroy((Object)(object)loaded[item]);
				loaded.Remove(item);
			}
		}

		private static void SetCacheDirectory(string url)
		{
			foreach (Texture2D value in loaded.Values)
			{
				Object.Destroy((Object)(object)value);
			}
			loaded.Clear();
			metas.Clear();
			refreshedThisSession.Clear();
			diskLoadQueue.Clear();
			diskLoadPending.Clear();
			using MD5 mD = MD5.Create();
			string path = string.Concat(from b in mD.ComputeHash(Encoding.UTF8.GetBytes(url)).Take(6)
				select b.ToString("x2"));
			cacheDirectory = Path.Combine(Path.Combine(Paths.CachePath, "SnakeSquadCartographySnapshot"), path);
			try
			{
				Directory.CreateDirectory(cacheDirectory);
				string[] files = Directory.GetFiles(cacheDirectory, "*.meta");
				foreach (string path2 in files)
				{
					string[] array = File.ReadAllLines(path2);
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path2);
					Meta meta = new Meta
					{
						Url = ((array.Length != 0) ? array[0] : ""),
						TileETag = ((array.Length > 1) ? array[1] : ""),
						OverviewETag = ((array.Length > 2) ? array[2] : ""),
						ContentHash = ((array.Length > 3) ? array[3] : "")
					};
					if (array.Length >= 3 && (meta.IsEmpty || File.Exists(Path.Combine(cacheDirectory, fileNameWithoutExtension + ".png"))))
					{
						metas[fileNameWithoutExtension] = meta;
					}
				}
				logger.LogInfo((object)$"Map tile cache: {metas.Count} tiles saved in {cacheDirectory}.");
			}
			catch (Exception ex)
			{
				logger.LogWarning((object)("Couldn't use the map tile cache folder " + cacheDirectory + " - tiles won't be saved between sessions: " + ex.Message));
				cacheDirectory = null;
			}
		}

		private static void SaveMeta(string key, Meta meta)
		{
			if (cacheDirectory != null)
			{
				File.WriteAllLines(Path.Combine(cacheDirectory, key + ".meta"), new string[4] { meta.Url, meta.TileETag, meta.OverviewETag, meta.ContentHash });
			}
		}

		private static IEnumerator LoadManifest(bool fresh)
		{
			manifest = null;
			string text = (snapshotUrl.Contains("?") ? "&" : "?");
			string text2 = string.Join(",", Levels.Select((Level l) => F(l.CellWorldSize)));
			string text3 = snapshotUrl + text + "manifest=1&cells=" + text2 + (fresh ? "&fresh=1" : "");
			UnityWebRequest request = UnityWebRequest.Get(text3);
			try
			{
				request.timeout = Mathf.Max(timeoutSeconds, 30);
				CartographySnapshotPlugin.PrepareSnapshotRequest(request, snapshotKey);
				yield return request.SendWebRequest();
				if (CartographySnapshotPlugin.IsAccessDenied(request))
				{
					accessDenied = true;
					yield break;
				}
				DownloadHandler downloadHandler = request.downloadHandler;
				byte[] bytes = ((downloadHandler != null) ? downloadHandler.data : null) ?? Array.Empty<byte>();
				if (request.responseCode != 200 || (int)request.result != 1 || IsPng(bytes))
				{
					logger.LogInfo((object)$"Map tiles: no tile manifest from the server (HTTP {request.responseCode}) - re-checking every tile whose map version is out of date.");
					yield break;
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				string[] array = request.downloadHandler.text.Split(new char[1] { '\n' });
				foreach (string obj in array)
				{
					string text4 = obj.Trim();
					if (text4.Length != 0 && !text4.StartsWith("#"))
					{
						string[] array2 = text4.Split(new char[2] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
						float size;
						Level level = ((array2.Length == 4 && float.TryParse(array2[0], NumberStyles.Float, CultureInfo.InvariantCulture, out size)) ? Levels.FirstOrDefault((Level l) => Mathf.Approximately(l.CellWorldSize, size)) : null);
						if (level == null || !int.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !int.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
						{
							logger.LogWarning((object)("Map tiles: couldn't read tile manifest line \"" + text4 + "\" - ignoring the manifest."));
							yield break;
						}
						dictionary[CellKey(level.Index, result, result2)] = array2[3];
					}
				}
				manifest = dictionary;
				logger.LogInfo((object)$"Map tiles: tile manifest lists {dictionary.Count} non-empty tiles.");
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private static string? ManifestHash(Cell cell)
		{
			if (manifest == null)
			{
				return null;
			}
			if (!manifest.TryGetValue(cell.Key, out string value))
			{
				return "-";
			}
			return value;
		}

		private static void ApplyManifest()
		{
			if (manifest == null)
			{
				return;
			}
			bool flag = false;
			foreach (Cell cell in cells)
			{
				string text = ManifestHash(cell);
				metas.TryGetValue(cell.Key, out Meta value);
				if (text == "-")
				{
					if (value != null && value.IsEmpty && value.Url == cell.Url && value.OverviewETag == overviewETag)
					{
						continue;
					}
					Meta meta = new Meta
					{
						Url = cell.Url,
						OverviewETag = overviewETag,
						ContentHash = "-"
					};
					metas[cell.Key] = meta;
					try
					{
						SaveMeta(cell.Key, meta);
						if (cacheDirectory != null)
						{
							File.Delete(Path.Combine(cacheDirectory, cell.Key + ".png"));
						}
					}
					catch (Exception ex)
					{
						logger.LogWarning((object)("Couldn't update saved map tile " + cell.Key + ": " + ex.Message));
					}
					if (value != null && !value.IsEmpty)
					{
						CountUpdated(cell);
					}
					if (loaded.TryGetValue(cell.Key, out Texture2D value2))
					{
						loaded.Remove(cell.Key);
						Object.Destroy((Object)(object)value2);
						flag = true;
					}
				}
				else if (value != null && !value.IsEmpty && value.Url == cell.Url && value.ContentHash == text && value.OverviewETag != overviewETag)
				{
					value.OverviewETag = overviewETag;
					SaveMeta(cell.Key, value);
				}
			}
			if (flag)
			{
				TileCache.TexturesChanged?.Invoke();
			}
		}

		private static string ShortBody(UnityWebRequest request)
		{
			DownloadHandler downloadHandler = request.downloadHandler;
			string text = ((downloadHandler != null) ? downloadHandler.text : null) ?? "";
			text = text.Replace('\n', ' ').Replace('\r', ' ');
			if (text.Length <= 200)
			{
				return text;
			}
			return text.Substring(0, 200) + "...";
		}

		private static float ParseRetryAfterSeconds(string? header)
		{
			if (string.IsNullOrEmpty(header) || !float.TryParse(header, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || !(result > 0f))
			{
				return 2f;
			}
			return result;
		}

		private static string F(float value)
		{
			return value.ToString(CultureInfo.InvariantCulture);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}