using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using InControl;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Silksong.ScreenshotMarker;
using Silksong.ScreenshotMarker.Extensions;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.UIElements;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Silksong.ScreenshotMarker")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.2.0")]
[assembly: AssemblyInformationalVersion("1.2.2+b4d703337d8ce3abc66d499972bef801b8676ef1")]
[assembly: AssemblyProduct("Silksong.ScreenshotMarker")]
[assembly: AssemblyTitle("ScreenshotMarker")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DemoJameson/Silksong.ScreenshotMarker")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
public class ScreenshotDisplay : MonoBehaviour
{
	private static ScreenshotDisplay? instance;

	private Texture2D? screenshotTexture;

	private Sprite? screenshotSprite;

	public static bool IsShowing => (Object)(object)instance != (Object)null;

	public static void Show(string filePath)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		if (Object.op_Implicit((Object)(object)instance))
		{
			Close();
		}
		instance = new GameObject("ScreenshotMarker_ScreenshotDisplay").AddComponent<ScreenshotDisplay>();
		instance.InitializeUI(filePath);
	}

	public static void Close()
	{
		if (Object.op_Implicit((Object)(object)instance))
		{
			Object.Destroy((Object)(object)((Component)instance).gameObject);
			instance = null;
		}
	}

	private void InitializeUI(string filePath)
	{
		//IL_003a: 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: Expected O, but got Unknown
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: 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_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_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)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Expected O, but got Unknown
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: 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_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		Canvas obj = ((Component)this).gameObject.AddComponent<Canvas>();
		obj.renderMode = (RenderMode)0;
		obj.sortingOrder = 9999;
		CanvasScaler obj2 = ((Component)this).gameObject.AddComponent<CanvasScaler>();
		obj2.uiScaleMode = (ScaleMode)1;
		obj2.referenceResolution = new Vector2((float)Screen.width, (float)Screen.height);
		GameObject val = new GameObject("ScreenshotMarker_Panel");
		val.transform.SetParent(((Component)this).transform, false);
		((Graphic)val.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.8f);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = Vector2.zero;
		component.anchorMax = Vector2.one;
		component.sizeDelta = Vector2.zero;
		GameObject val2 = new GameObject("ScreenshotMarker_Image");
		val2.transform.SetParent(val.transform, false);
		Image obj3 = val2.AddComponent<Image>();
		byte[] array = File.ReadAllBytes(filePath);
		screenshotTexture = new Texture2D(2, 2);
		ImageConversion.LoadImage(screenshotTexture, array);
		screenshotSprite = Sprite.Create(screenshotTexture, new Rect(0f, 0f, (float)((Texture)screenshotTexture).width, (float)((Texture)screenshotTexture).height), new Vector2(0.5f, 0.5f));
		obj3.sprite = screenshotSprite;
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(0.5f, 0.5f);
		component2.anchorMax = new Vector2(0.5f, 0.5f);
		component2.pivot = new Vector2(0.5f, 0.5f);
		float value = PluginConfig.ScreenshotScale.Value;
		float num = (float)Screen.width * value;
		float num2 = (float)Screen.height * value;
		float num3 = (float)((Texture)screenshotTexture).width / (float)((Texture)screenshotTexture).height;
		float num4;
		float num5;
		if (num / num2 > num3)
		{
			num4 = num2;
			num5 = num4 * num3;
		}
		else
		{
			num5 = num;
			num4 = num5 / num3;
		}
		component2.sizeDelta = new Vector2(num5, num4);
		((Component)this).gameObject.AddComponent<ScreenshotDisplayController>();
	}

	private void OnDestroy()
	{
		if ((Object)(object)screenshotSprite != (Object)null)
		{
			Object.Destroy((Object)(object)screenshotSprite);
		}
		if ((Object)(object)screenshotTexture != (Object)null)
		{
			Object.Destroy((Object)(object)screenshotTexture);
		}
	}
}
public class ScreenshotDisplayController : MonoBehaviour
{
	private void Update()
	{
		HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
		if (PluginConfig.ScreenshotKey.IsDown() || Input.GetKeyDown((KeyCode)27) || ((OneAxisInputControl)inputActions.MenuSubmit).WasPressed || ((OneAxisInputControl)inputActions.MenuCancel).WasPressed || ((OneAxisInputControl)inputActions.MenuExtra).WasPressed || ((OneAxisInputControl)inputActions.MenuSuper).WasPressed || ((OneAxisInputControl)inputActions.Jump).WasPressed || ((OneAxisInputControl)inputActions.Evade).WasPressed || ((OneAxisInputControl)inputActions.Dash).WasPressed || ((OneAxisInputControl)inputActions.SuperDash).WasPressed || ((OneAxisInputControl)inputActions.DreamNail).WasPressed || ((OneAxisInputControl)inputActions.Attack).WasPressed || ((OneAxisInputControl)inputActions.Cast).WasPressed || ((OneAxisInputControl)inputActions.QuickMap).WasPressed || ((OneAxisInputControl)inputActions.QuickCast).WasPressed || ((OneAxisInputControl)inputActions.Taunt).WasPressed || ((OneAxisInputControl)inputActions.OpenInventory).WasPressed || ((OneAxisInputControl)inputActions.OpenInventoryMap).WasPressed || ((OneAxisInputControl)inputActions.OpenInventoryJournal).WasPressed || ((OneAxisInputControl)inputActions.OpenInventoryTools).WasPressed || ((OneAxisInputControl)inputActions.OpenInventoryQuests).WasPressed || ((OneAxisInputControl)inputActions.Pause).WasPressed)
		{
			ScreenshotDisplay.Close();
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Silksong.ScreenshotMarker
{
	public record MarkerData
	{
		public string Name;

		public DateTime Time;

		public string FileName;

		public Vector2 Position;

		[CompilerGenerated]
		protected virtual bool PrintMembers(StringBuilder builder)
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("Name = ");
			builder.Append((object?)Name);
			builder.Append(", Time = ");
			builder.Append(Time.ToString());
			builder.Append(", FileName = ");
			builder.Append((object?)FileName);
			builder.Append(", Position = ");
			builder.Append(((object)(Vector2)(ref Position)).ToString());
			return true;
		}
	}
	[HarmonyPatch]
	public class MarkerManager : PluginComponent
	{
		[CompilerGenerated]
		private sealed class <CreateFlashEffect>d__28 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private GameObject <flashObject>5__2;

			private Image <flashImage>5__3;

			private float <defaultAlpha>5__4;

			private float <duration>5__5;

			private float <elapsed>5__6;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CreateFlashEffect>d__28(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<flashObject>5__2 = null;
				<flashImage>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<flashObject>5__2 = new GameObject("ScreenshotMarker_Flash");
					Canvas obj = <flashObject>5__2.AddComponent<Canvas>();
					obj.renderMode = (RenderMode)0;
					obj.sortingOrder = 9999;
					CanvasScaler obj2 = <flashObject>5__2.AddComponent<CanvasScaler>();
					obj2.uiScaleMode = (ScaleMode)1;
					obj2.referenceResolution = new Vector2(1920f, 1080f);
					<flashImage>5__3 = <flashObject>5__2.AddComponent<Image>();
					<defaultAlpha>5__4 = 0.25f;
					((Graphic)<flashImage>5__3).color = new Color(1f, 1f, 1f, <defaultAlpha>5__4);
					<duration>5__5 = 0.3f;
					<elapsed>5__6 = 0f;
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__6 < <duration>5__5)
				{
					<elapsed>5__6 += Time.deltaTime;
					float num = Mathf.Lerp(<defaultAlpha>5__4, 0f, <elapsed>5__6 / <duration>5__5);
					((Graphic)<flashImage>5__3).color = new Color(1f, 1f, 1f, num);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				Object.Destroy((Object)(object)<flashObject>5__2);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <CreateScreenshotMarker>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CreateScreenshotMarker>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//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_006b: 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_0076: 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_009a: 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_0127: 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_0163: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					int currentSaveSlot = MarkerManager.currentSaveSlot;
					GameMap gameMap = GameManager._instance.gameMap;
					gameMap.UpdateCurrentScene();
					Vector2 mapPosition = gameMap.GetMapPosition(Vector2.op_Implicit(HeroController._instance.transform.position), gameMap.currentScene, gameMap.currentSceneObj, gameMap.currentScenePos, gameMap.currentSceneSize);
					foreach (MarkerData item2 in markerDataList.ToList())
					{
						if (Vector2.Distance(item2.Position, mapPosition) < 0.1f)
						{
							RemoveMarkerData(item2);
						}
					}
					string fileName = DateTime.Now.ToString("yyyyMMdd_HHmmss_fff") + (RenoDxOrLumaEnabled ? ".exr" : ".png");
					string screenshotFilePath = GetScreenshotFilePath(currentSaveSlot, fileName);
					MarkerData item = new MarkerData
					{
						Name = PluginComponent.CurrentSceneName,
						Time = DateTime.Now,
						FileName = fileName,
						Position = mapPosition
					};
					Directory.CreateDirectory(GetScreenshotPath(currentSaveSlot));
					TakeScreenshot(screenshotFilePath);
					markerDataList.Add(item);
					SaveMakers(currentSaveSlot);
					MapMarkerMenu mapMarkerMenu = gameMap.mapManager.mapMarkerMenu;
					VibrationManager.PlayVibrationClipOneShot(mapMarkerMenu.placementVibration, (VibrationTarget?)null, false, "", false);
					if (!Object.op_Implicit((Object)(object)placeAudioSource))
					{
						placeAudioSource = new GameObject("ScreenshotMarker_PlaceAudioSource").AddComponent<AudioSource>();
						AudioClip placeClip = mapMarkerMenu.placeClip;
						placeAudioSource.clip = placeClip;
					}
					placeAudioSource.Play();
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static List<MarkerData> markerDataList = new List<MarkerData>();

		private static List<GameObject> spawnedMapMarkers = new List<GameObject>();

		private static Sprite sprite;

		private static string markerNamePrefix = "ScreenshotMarker_";

		private static MarkerTypes ScreenshotMarkerType = (MarkerTypes)9527;

		private static AudioSource placeAudioSource = null;

		private static bool? renoDxOrLumaEnabled;

		private static int currentSaveSlot => GameManager._instance.profileID;

		private static bool RenoDxOrLumaEnabled
		{
			get
			{
				if (renoDxOrLumaEnabled.HasValue)
				{
					return renoDxOrLumaEnabled.Value;
				}
				if (File.Exists(Path.Combine(Paths.GameRootPath, "dxgi.dll")))
				{
					renoDxOrLumaEnabled = File.Exists(Path.Combine(Paths.GameRootPath, "renodx-hollowknight-silksong.addon64")) || File.Exists(Path.Combine(Paths.GameRootPath, "Luma-Unity Engine.addon"));
				}
				else
				{
					renoDxOrLumaEnabled = false;
				}
				return renoDxOrLumaEnabled.Value;
			}
		}

		private void Awake()
		{
			//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)
			//IL_0019: Expected O, but got Unknown
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			byte[] embeddedResourceBytes = GetEmbeddedResourceBytes("ScreenshotMarker.png");
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, embeddedResourceBytes);
			sprite = Sprite.Create(val, new Rect(0f, 0f, 73f, 73f), Vector2.one / 2f);
			if (Object.op_Implicit((Object)(object)GameManager._instance) && currentSaveSlot > 0)
			{
				LoadMarkers(currentSaveSlot);
			}
		}

		private void OnDestroy()
		{
			foreach (GameObject spawnedMapMarker in spawnedMapMarkers)
			{
				Object.Destroy((Object)(object)spawnedMapMarker);
			}
			Object.Destroy((Object)(object)sprite);
			Object.Destroy((Object)(object)placeAudioSource);
			ScreenshotDisplay.Close();
		}

		private void LateUpdate()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			if (!PluginConfig.Enabled.Value || !Object.op_Implicit((Object)(object)HeroController._instance) || HeroController._instance.IsInputBlocked() || (Object.op_Implicit((Object)(object)GameManager._instance) && ((int)GameManager._instance.GameState != 4 || (GameManager._instance.IsMemoryScene() && (int)GameManager._instance.GetCurrentMapZoneEnum() != 21))))
			{
				return;
			}
			HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
			if ((PluginConfig.ScreenshotKey.IsDown() || (((OneAxisInputControl)inputActions.QuickMap).WasPressed && ((OneAxisInputControl)inputActions.DreamNail).IsPressed)) && currentSaveSlot > 0)
			{
				((MonoBehaviour)this).StartCoroutine(CreateScreenshotMarker());
				if (PluginConfig.FlashEffect.Value)
				{
					((MonoBehaviour)this).StartCoroutine(CreateFlashEffect());
				}
			}
		}

		private static string GetScreenshotPath(int saveSlot)
		{
			return Path.Combine(Paths.ConfigPath, "ScreenshotMarker", "Save_" + saveSlot);
		}

		private static string GetScreenshotFilePath(int saveSlot, string fileName)
		{
			return Path.Combine(GetScreenshotPath(saveSlot), fileName);
		}

		private static string GetMarkerDataPath(int saveSlot)
		{
			return Path.Combine(GetScreenshotPath(saveSlot), "marker_data.json");
		}

		[IteratorStateMachine(typeof(<CreateScreenshotMarker>d__14))]
		private static IEnumerator CreateScreenshotMarker()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CreateScreenshotMarker>d__14(0);
		}

		private static GameObject CreateMarker(GameMap gameMap, int index)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (spawnedMapMarkers.Count > index)
			{
				return spawnedMapMarkers[index];
			}
			GameObject val = Object.Instantiate<GameObject>(gameMap.mapMarkerTemplates[0], gameMap.markerParent);
			((Object)val).name = $"{markerNamePrefix}{index}";
			SpriteRenderer componentInChildren = val.GetComponentInChildren<SpriteRenderer>();
			componentInChildren.sprite = sprite;
			MaterialPropertyBlock val2 = new MaterialPropertyBlock();
			val2.SetFloat(Shader.PropertyToID("_TimeOffset"), Random.Range(0f, 10f));
			((Renderer)componentInChildren).SetPropertyBlock(val2);
			InvMarker componentInChildren2 = val.GetComponentInChildren<InvMarker>();
			componentInChildren2.Colour = ScreenshotMarkerType;
			componentInChildren2.Index = index;
			spawnedMapMarkers.Add(val);
			return val;
		}

		[HarmonyPatch(typeof(MapMarkerMenu), "AddToCollidingList")]
		[HarmonyPostfix]
		private static void MapMarkerMenuAddToCollidingList(MapMarkerMenu __instance)
		{
			//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_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)
			List<GameObject> collidingMarkers = __instance.collidingMarkers;
			Vector3 cursorPosition = __instance.placementCursor.transform.position;
			Vector3 gameMapPosition = ((Component)__instance.gameMap).transform.parent.position;
			collidingMarkers.Sort(delegate(GameObject go1, GameObject go2)
			{
				//IL_0006: 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_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_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_0032: 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_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)
				//IL_0048: 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)
				float num = Vector2.Distance(Vector2.op_Implicit(go1.transform.position - gameMapPosition), Vector2.op_Implicit(cursorPosition));
				float num2 = Vector2.Distance(Vector2.op_Implicit(go2.transform.position - gameMapPosition), Vector2.op_Implicit(cursorPosition)) - num;
				if (num2 > 0f)
				{
					return 1;
				}
				return (num2 < 0f) ? (-1) : 0;
			});
		}

		[HarmonyPatch(typeof(Platform), "GetMenuAction", new Type[]
		{
			typeof(HeroActions),
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static bool InventoryItemSelectedActionDoAction()
		{
			if (ScreenshotDisplay.IsShowing)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(MapMarkerMenu), "Update")]
		[HarmonyPrefix]
		private static bool MapMarkerMenuUpdate(MapMarkerMenu __instance)
		{
			//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)
			//IL_0076: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			if (__instance.inPlacementMode && __instance.collidingMarkers.Count > 0 && !ScreenshotDisplay.IsShowing)
			{
				HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
				MenuActions menuAction = Platform.Current.GetMenuAction(inputActions, false, false);
				if (PluginConfig.ScreenshotKey.IsDown() || ((OneAxisInputControl)inputActions.QuickMap).WasPressed || (int)menuAction == 3)
				{
					List<GameObject> collidingMarkers = __instance.collidingMarkers;
					InvMarker component = collidingMarkers[collidingMarkers.Count - 1].GetComponent<InvMarker>();
					if (component.Colour != ScreenshotMarkerType)
					{
						return true;
					}
					MarkerData markerData = markerDataList[component.Index];
					string screenshotFilePath = GetScreenshotFilePath(currentSaveSlot, markerData.FileName);
					if (File.Exists(screenshotFilePath))
					{
						ScreenshotDisplay.Show(screenshotFilePath);
					}
					else
					{
						RemoveScreenshotMarker(__instance);
					}
					return false;
				}
			}
			if (ScreenshotDisplay.IsShowing)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(MapMarkerMenu), "RemoveMarker")]
		[HarmonyPrefix]
		private static bool RemoveMarker(MapMarkerMenu __instance)
		{
			//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)
			List<GameObject> collidingMarkers = __instance.collidingMarkers;
			if (collidingMarkers[collidingMarkers.Count - 1].GetComponent<InvMarker>().Colour != ScreenshotMarkerType)
			{
				return true;
			}
			RemoveScreenshotMarker(__instance);
			return false;
		}

		private static void RemoveScreenshotMarker(MapMarkerMenu markerMenu)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> collidingMarkers = markerMenu.collidingMarkers;
			GameObject val = collidingMarkers[collidingMarkers.Count - 1];
			InvMarker component = val.GetComponent<InvMarker>();
			RemoveMarkerData(markerDataList[component.Index]);
			collidingMarkers.Remove(val);
			if (collidingMarkers.Count <= 0)
			{
				markerMenu.IsNotColliding();
			}
			markerMenu.audioSource.PlayOneShot(markerMenu.removeClip);
			VibrationManager.PlayVibrationClipOneShot(markerMenu.placementVibration, (VibrationTarget?)null, false, "", false);
			markerMenu.gameMap.SetupMapMarkers();
		}

		[HarmonyPatch(typeof(GameMap), "SetupMapMarkers")]
		[HarmonyPostfix]
		private static void SetupMapMarkers(GameMap __instance)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (PluginConfig.Enabled.Value && !CollectableItemManager.IsInHiddenMode())
			{
				for (int i = 0; i < IEnumerableExtensions.GetCount((IEnumerable)markerDataList); i++)
				{
					GameObject obj = CreateMarker(__instance, i);
					obj.SetActive(true);
					Extensions.SetLocalPosition2D(obj.transform, markerDataList[i].Position);
				}
			}
		}

		[HarmonyPatch(typeof(GameMap), "DisableMarkers")]
		[HarmonyPostfix]
		private static void DisableMarkers()
		{
			foreach (GameObject spawnedMapMarker in spawnedMapMarkers)
			{
				Object.Destroy((Object)(object)spawnedMapMarker);
			}
			spawnedMapMarkers.Clear();
		}

		[HarmonyPatch(typeof(GameManager), "SetLoadedGameData", new Type[]
		{
			typeof(SaveGameData),
			typeof(int)
		})]
		[HarmonyPostfix]
		private static void LoadMarkers(int saveSlot)
		{
			if (!File.Exists(GetMarkerDataPath(saveSlot)))
			{
				markerDataList.Clear();
			}
			else
			{
				markerDataList = JsonConvert.DeserializeObject<List<MarkerData>>(File.ReadAllText(GetMarkerDataPath(saveSlot))) ?? new List<MarkerData>();
			}
		}

		[HarmonyPatch(typeof(GameManager), "ClearSaveFile")]
		[HarmonyPostfix]
		private static void ClearMarkers(int saveSlot)
		{
			if (Directory.Exists(GetScreenshotPath(saveSlot)))
			{
				Directory.Delete(GetScreenshotPath(saveSlot), recursive: true);
			}
			markerDataList.Clear();
		}

		private static void SaveMakers(int saveSlot)
		{
			File.WriteAllText(GetMarkerDataPath(saveSlot), JsonConvert.SerializeObject((object)markerDataList));
		}

		private static void RemoveMarkerData(MarkerData markerData)
		{
			if (markerDataList.Remove(markerData))
			{
				File.Delete(GetScreenshotFilePath(currentSaveSlot, markerData.FileName));
				SaveMakers(currentSaveSlot);
			}
		}

		private static void TakeScreenshot(string filePath)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			int width = Screen.width;
			int height = Screen.height;
			float num = (float)width / (float)height;
			int num2 = Mathf.Min(height, 1080);
			int num3 = Mathf.RoundToInt(num * (float)num2);
			Camera main = Camera.main;
			RenderTexture targetTexture = main.targetTexture;
			RenderTexture active = RenderTexture.active;
			RenderTexture val2 = (main.targetTexture = new RenderTexture(num3, num2, 24, (RenderTextureFormat)(RenoDxOrLumaEnabled ? 2 : 7)));
			main.Render();
			RenderTexture.active = val2;
			Texture2D val3 = new Texture2D(num3, num2, (TextureFormat)(RenoDxOrLumaEnabled ? 17 : 3), false);
			val3.ReadPixels(new Rect(0f, 0f, (float)num3, (float)num2), 0, 0);
			if (RenoDxOrLumaEnabled)
			{
				Color[] pixels = val3.GetPixels();
				for (int i = 0; i < pixels.Length; i++)
				{
					pixels[i].a = 1f;
				}
				val3.SetPixels(pixels);
			}
			val3.Apply();
			if (RenoDxOrLumaEnabled)
			{
				File.WriteAllBytes(filePath, ImageConversion.EncodeToEXR(val3, (EXRFlags)8));
			}
			else
			{
				File.WriteAllBytes(filePath, ImageConversion.EncodeToPNG(val3));
			}
			main.targetTexture = targetTexture;
			RenderTexture.active = active;
			Object.Destroy((Object)(object)val2);
			Object.Destroy((Object)(object)val3);
		}

		[IteratorStateMachine(typeof(<CreateFlashEffect>d__28))]
		private static IEnumerator CreateFlashEffect()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CreateFlashEffect>d__28(0);
		}

		private static byte[] GetEmbeddedResourceBytes(string resourceName)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = "Silksong.ScreenshotMarker." + resourceName;
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				throw new ArgumentException("找不到资源: " + text);
			}
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}
	}
	[BepInPlugin("mod.silksong.screenshotmarker", "Screenshot Marker", "1.2.2")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "mod.silksong.screenshotmarker";

		public static Plugin Instance { get; private set; }

		public static ManualLogSource LogSource => ((BaseUnityPlugin)Instance).Logger;

		public static string Name => "Screenshot Marker";

		public static string Version => "1.2.2";

		private void Awake()
		{
			Instance = this;
			PluginComponent.Initialize(((Component)this).gameObject);
		}
	}
	public abstract class PluginComponent : MonoBehaviour
	{
		private static string? currentSceneName;

		public static ManualLogSource Logger => Plugin.LogSource;

		public static string CurrentSceneName => GameManager.instance.sceneName;

		public static string PreviousSceneName => GameManager.instance.lastSceneName;

		public static void Initialize(GameObject gameObject)
		{
			List<Type> list = (from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && type.IsSubclassOf(typeof(PluginComponent))
				select type).ToList();
			list.Sort((Type type, Type otherType) => GetPriority(otherType) - GetPriority(type));
			foreach (Type item in list)
			{
				gameObject.AddComponent(item);
			}
		}

		private static int GetPriority(Type type)
		{
			object[] customAttributes = type.GetCustomAttributes(typeof(PluginComponentPriorityAttribute), inherit: false);
			int num = 0;
			if (num < customAttributes.Length)
			{
				return ((PluginComponentPriorityAttribute)customAttributes[num]).Priority;
			}
			return 0;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class PluginComponentPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public PluginComponentPriorityAttribute(int priority)
		{
			Priority = priority;
			base..ctor();
		}
	}
	public class PluginConfig : PluginComponent
	{
		public static ConfigEntry<bool> Enabled { get; private set; }

		public static ConfigEntry<bool> FlashEffect { get; private set; }

		public static ConfigEntry<float> ScreenshotScale { get; private set; }

		public static ConfigEntry<KeyboardShortcut> ScreenshotKey { get; private set; }

		private void Awake()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			Enabled = config.Bind<bool>("General", "Screenshot Marker", true, "Whether to enable screenshot marker");
			FlashEffect = config.Bind<bool>("General", "Flash Effect", true, "Whether to enable flash effect when taking a screenshot");
			ScreenshotScale = config.Bind<float>("General", "Screenshot Scale", 0.75f, new ConfigDescription("The scale of the screenshot", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			ScreenshotKey = config.Bind<KeyboardShortcut>("General", "Screenshot Key", new KeyboardShortcut((KeyCode)112, Array.Empty<KeyCode>()), "The key to take a screenshot and remove marker");
		}
	}
	public class PluginPatch : PluginComponent
	{
		private Harmony harmony;

		private void Awake()
		{
			harmony = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
		}
	}
}
namespace Silksong.ScreenshotMarker.Extensions
{
	public static class ConfigEntryExtensions
	{
		public static bool IsDown(this ConfigEntry<KeyboardShortcut> configEntry)
		{
			//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_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_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_0023: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = configEntry.Value;
			if (!((KeyboardShortcut)(ref value)).Modifiers.Any())
			{
				IInputSystem current = UnityInput.Current;
				value = configEntry.Value;
				return current.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey);
			}
			value = configEntry.Value;
			return ((KeyboardShortcut)(ref value)).IsDown();
		}
	}
	public static class ListExtensions
	{
		public static T? GetOrDefault<T>(this List<T> list, int index)
		{
			if (list.Count > index)
			{
				return list[index];
			}
			return default(T);
		}
	}
}