using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
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.Xml.Linq;
using BepInEx;
using BepInEx.Logging;
using GlobalEnums;
using GlobalSettings;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour;
using Newtonsoft.Json;
using PrepatcherPlugin;
using QuestPlaymakerActions;
using Silksong.DataManager;
using Silksong.FsmUtil;
using Silksong.Rando.Data;
using Silksong.Rando.Data.Extractors;
using Silksong.Rando.Locations;
using Silksong.Rando.Logic;
using Silksong.Rando.Map;
using SkongGamemodes;
using TeamCherry.Localization;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceProviders;
using UnityEngine.SceneManagement;

[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.Rando")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.3.0")]
[assembly: AssemblyInformationalVersion("0.1.3+68feacc47410b7d16861dc9f72980cbd34406e60")]
[assembly: AssemblyProduct("Silksong.Rando")]
[assembly: AssemblyTitle("Rando")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/timothymarriott/Silksong-Rando")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.3.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;
		}
	}
}
[HarmonyPatch(typeof(Language), "Get", new Type[]
{
	typeof(string),
	typeof(string)
})]
internal class Language_Get_Patch
{
	public static bool Prefix(ref string __result, string key, string sheetTitle)
	{
		if (sheetTitle == "Rando")
		{
			__result = key;
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(Language), "Has", new Type[]
{
	typeof(string),
	typeof(string)
})]
internal class Language_Has_Patch
{
	public static bool Prefix(ref bool __result, string key, string sheetTitle)
	{
		if (sheetTitle == "Rando")
		{
			__result = true;
			return false;
		}
		return true;
	}
}
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 Generated
{
	public static class BuildConstants
	{
		public const string Version = "0.1.3";

		public const string GitHubRepo = "timothymarriott/Silksong-Rando";
	}
}
namespace Silksong.Rando
{
	public static class AssemblyExtensions
	{
		public static Sprite LoadEmbeddedSprite(this Assembly asm, string path, float pixelsPerUnit = 64f)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			using Stream stream = asm.GetManifestResourceStream(path);
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array, false);
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), Vector2.one * 0.5f, pixelsPerUnit);
		}

		public static string LoadEmbeddedText(this Assembly asm, string path)
		{
			using Stream stream = asm.GetManifestResourceStream(path);
			if (stream == null)
			{
				throw new InvalidOperationException("Resource not found: " + path);
			}
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}
	}
	public abstract class DataBuilder<TResult>
	{
		public TResult result;

		public bool IsBuilt { get; protected set; }
	}
	public class ModResources : MonoBehaviour
	{
		public static ManualLogSource Logger;

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

		private static Dictionary<string, string> Data = new Dictionary<string, string>();

		public Font trajanBold;

		public Font trajanNormal;

		public Font arial;

		public static Sprite LoadSprite(string id, float pixelsPerUnit = 64f)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!Images.TryGetValue(id, out Sprite value))
			{
				return Sprite.Create(Texture2D.whiteTexture, new Rect(0f, 0f, 4f, 4f), Vector2.one * 0.5f, pixelsPerUnit);
			}
			return value;
		}

		public static string LoadData(string id)
		{
			if (!Data.TryGetValue(id, out string value))
			{
				throw new KeyNotFoundException(id);
			}
			return value;
		}

		public static Stream GetResourceStream(string id)
		{
			string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (text.EndsWith(".json") && text.StartsWith("Silksong.Rando.Resources.") && text.Substring("Silksong.Rando.Resources.".Length).Replace(".json", "").Replace(".png", "")
					.Replace('.', '/') == id)
				{
					return Assembly.GetExecutingAssembly().GetManifestResourceStream(text);
				}
			}
			throw new FileNotFoundException();
		}

		public static AssetBundle LoadAssetBundle(string id)
		{
			string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (text.EndsWith(".bundle") && text.StartsWith("Silksong.Rando.Resources.") && text.Substring("Silksong.Rando.Resources.".Length).Replace(".bundle", "").Replace('.', '/') == id)
				{
					Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(text);
					using MemoryStream memoryStream = new MemoryStream();
					manifestResourceStream.CopyTo(memoryStream);
					return AssetBundle.LoadFromMemory(memoryStream.ToArray());
				}
			}
			throw new FileNotFoundException();
		}

		public static ModResources LoadResources(ManualLogSource logger)
		{
			Logger = logger;
			string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (text.EndsWith(".png") && text.StartsWith("Silksong.Rando.Resources.Images."))
				{
					try
					{
						string text2 = text.Substring("Silksong.Rando.Resources.Images.".Length).Replace(".png", "").Replace('.', '/');
						Images.Add(text2, Assembly.GetExecutingAssembly().LoadEmbeddedSprite(text));
						Logger.LogInfo((object)("Loaded image: " + text2));
					}
					catch (Exception ex)
					{
						Logger.LogInfo((object)("Failed to load image: " + text + "\n" + ex.ToString()));
					}
				}
				if (text.EndsWith(".json") && text.StartsWith("Silksong.Rando.Resources."))
				{
					string key = text.Substring("Silksong.Rando.Resources.".Length).Replace(".json", "").Replace('.', '/');
					Data.Add(key, Assembly.GetExecutingAssembly().LoadEmbeddedText(text));
				}
			}
			return ((Component)RandoPlugin.instance).gameObject.AddComponent<ModResources>();
		}

		private void Update()
		{
			if (!((Object)(object)trajanBold == (Object)null) && !((Object)(object)trajanNormal == (Object)null) && !((Object)(object)arial == (Object)null))
			{
				return;
			}
			Font[] array = Resources.FindObjectsOfTypeAll<Font>();
			foreach (Font val in array)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name == "TrajanPro-Bold")
				{
					trajanBold = val;
				}
				if ((Object)(object)val != (Object)null && ((Object)val).name == "TrajanPro-Regular")
				{
					trajanNormal = val;
				}
				if ((Object)(object)val != (Object)null && ((Object)val).name == "Perpetua")
				{
					arial = val;
				}
			}
		}

		public static Font GetFont()
		{
			return RandoPlugin.instance.resources.arial;
		}

		public static GUIStyle GetLabelStyle()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_001a: 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_002a: Expected O, but got Unknown
			//IL_002b: Expected O, but got Unknown
			return new GUIStyle
			{
				fontSize = 30,
				fontStyle = (FontStyle)0,
				normal = new GUIStyleState
				{
					textColor = Color.white
				}
			};
		}
	}
	public class PlayerDataDelegateTestGroup : PlayerDataTest
	{
		public delegate bool IsFulfilledCallback(PlayerData data);

		private static bool initialised;

		private static Hook? isFulfilledHook;

		private readonly IsFulfilledCallback callback;

		public PlayerDataDelegateTestGroup(IsFulfilledCallback callback)
		{
			this.callback = callback;
			if (!initialised)
			{
				initialised = true;
				HookIsFulfilled();
			}
		}

		private static void HookIsFulfilled()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			isFulfilledHook = new Hook((MethodBase)typeof(PlayerDataTest).GetProperty("IsFulfilled", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(), (Delegate)new Func<Func<PlayerDataTest, bool>, PlayerDataTest, bool>(IsFulfilledDetour));
		}

		private static bool IsFulfilledDetour(Func<PlayerDataTest, bool> orig, PlayerDataTest self)
		{
			if (self is PlayerDataDelegateTestGroup playerDataDelegateTestGroup)
			{
				return playerDataDelegateTestGroup.callback(RandoPlugin.GM.playerData);
			}
			return orig(self);
		}
	}
	public class RandoItem : CollectableItemBasic
	{
		public delegate void OnCollectedCallback(RandoItem item);

		public string targetItem;

		public string check;

		public SavedItem wrapped;

		public OnCollectedCallback? CollectCallback;

		public override void OnCollected()
		{
			((CollectableItemBasic)this).OnCollected();
			RandoPlugin.Log.LogInfo((object)("Collected " + targetItem));
			SaveData.Instance.CollectedChecks.Add(check);
			if ((Object)(object)wrapped != (Object)null)
			{
				((CollectableItem)this).Take(1, false);
				RandoPlugin.Log.LogInfo((object)("Giving wrapped item: " + ((Object)wrapped).name + " at " + check + "(" + ((wrapped is RandoItem randoItem) ? randoItem.check : "vanilla wrapped") + ")"));
				wrapped.Get(false);
			}
			else if (CollectCallback != null)
			{
				CollectCallback(this);
			}
			RandoPlugin.instance.map.Refresh();
		}

		public static RandoItem Wrap(string targetItem, string check, SavedItem template)
		{
			RandoItemBuilder randoItemBuilder = RandoItemBuilder.Create(targetItem, check);
			((Object)randoItemBuilder.result).name = targetItem + "_wrap";
			((CollectableItemBasic)randoItemBuilder.result).icon = template.GetPopupIcon();
			((CollectableItemBasic)randoItemBuilder.result).tinyIcon = template.GetPopupIcon();
			if (template is RandoItem randoItem)
			{
				randoItem.check = check;
			}
			randoItemBuilder.result.wrapped = template;
			randoItemBuilder.SetDisplayName(template.GetPopupName());
			return randoItemBuilder.Build();
		}
	}
	public class RandoItemBuilder : DataBuilder<RandoItem>
	{
		private static List<RandoItemBuilder> created = new List<RandoItemBuilder>();

		public static RandoItemBuilder Create(string targetItem, string check)
		{
			RandoItemBuilder randoItemBuilder = new RandoItemBuilder();
			randoItemBuilder.result = ScriptableObject.CreateInstance<RandoItem>();
			((Object)randoItemBuilder.result).name = targetItem;
			randoItemBuilder.result.targetItem = targetItem;
			((CollectableItem)randoItemBuilder.result).isHidden = true;
			randoItemBuilder.result.check = check;
			randoItemBuilder.Setup();
			created.Add(randoItemBuilder);
			return randoItemBuilder;
		}

		private void Setup()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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)
			((CollectableItemBasic)result).isAlwaysUnlocked = true;
			((CollectableItemBasic)result).displayButtonPrompt = false;
			((CollectableItem)result).useResponses = (UseResponse[])(object)new UseResponse[1]
			{
				new UseResponse
				{
					UseType = (UseTypes)0
				}
			};
			((CollectableItemBasic)result).setExtraPlayerDataBools = (PlayerDataBoolOperation[])(object)new PlayerDataBoolOperation[0];
			((CollectableItemBasic)result).setExtraPlayerDataInts = (PlayerDataIntOperation[])(object)new PlayerDataIntOperation[0];
		}

		public RandoItemBuilder SetMaxAmount(int amount)
		{
			((CollectableItem)result).customMaxAmount = amount;
			return this;
		}

		public RandoItemBuilder SetDisplayName(string name)
		{
			return SetDisplayName("Rando", name);
		}

		public RandoItemBuilder SetDisplayName(string sheet, string key)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return SetDisplayName(new LocalisedString(sheet, key));
		}

		public RandoItemBuilder SetDisplayName(LocalisedString name)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			((CollectableItemBasic)result).displayName = name;
			return this;
		}

		public RandoItemBuilder SetDescription(string description)
		{
			return SetDescription("Rando", description);
		}

		public RandoItemBuilder SetDescription(string sheet, string key)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return SetDescription(new LocalisedString(sheet, key));
		}

		public RandoItemBuilder SetDescription(LocalisedString description)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			((CollectableItemBasic)result).description = description;
			return this;
		}

		public RandoItemBuilder SetIcon(Sprite sprite)
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)sprite == (Object)null)
			{
				return this;
			}
			Rect rect = sprite.rect;
			int num = (int)((Rect)(ref rect)).width;
			rect = sprite.rect;
			int num2 = (int)((Rect)(ref rect)).height;
			if (num <= 120 && num2 <= 120)
			{
				((CollectableItemBasic)result).icon = sprite;
				((CollectableItemBasic)result).tinyIcon = sprite;
				return this;
			}
			float num3 = Mathf.Min(120f / (float)num, 120f / (float)num2);
			int num4 = Mathf.RoundToInt((float)num * num3);
			int num5 = Mathf.RoundToInt((float)num2 * num3);
			Texture2D texture = sprite.texture;
			Rect rect2 = sprite.rect;
			Color[] pixels = texture.GetPixels((int)((Rect)(ref rect2)).x, (int)((Rect)(ref rect2)).y, (int)((Rect)(ref rect2)).width, (int)((Rect)(ref rect2)).height);
			Texture2D val = new Texture2D(num4, num5, texture.format, false);
			((Texture)val).filterMode = (FilterMode)1;
			for (int i = 0; i < num5; i++)
			{
				for (int j = 0; j < num4; j++)
				{
					float num6 = (float)j / (float)(num4 - 1);
					float num7 = (float)i / (float)(num5 - 1);
					int num8 = Mathf.RoundToInt(num6 * (float)(num - 1));
					int num9 = Mathf.RoundToInt(num7 * (float)(num2 - 1));
					val.SetPixel(j, i, pixels[num9 * num + num8]);
				}
			}
			val.Apply();
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)num4, (float)num5), new Vector2(0.5f, 0.5f), sprite.pixelsPerUnit);
			((CollectableItemBasic)result).icon = val2;
			((CollectableItemBasic)result).tinyIcon = val2;
			return this;
		}

		public RandoItemBuilder SetIcon(string icon)
		{
			return SetIcon(ModResources.LoadSprite(icon));
		}

		public RandoItemBuilder SetTinyIcon(Sprite sprite)
		{
			((CollectableItemBasic)result).tinyIcon = sprite;
			return this;
		}

		public RandoItemBuilder SetTinyIcon(string icon)
		{
			return SetTinyIcon(ModResources.LoadSprite(icon));
		}

		public RandoItemBuilder SetCollectCallback(RandoItem.OnCollectedCallback action)
		{
			result.CollectCallback = action;
			return this;
		}

		public RandoItem Build()
		{
			if (base.IsBuilt)
			{
				return result;
			}
			base.IsBuilt = true;
			((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).Add((CollectableItem)(object)result);
			return result;
		}
	}
	[BepInPlugin("com.lem00ns.Silksong.Rando", "Randomiser", "0.1.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class RandoPlugin : BaseUnityPlugin, ISaveDataMod<SaveData>, ISaveDataMod
	{
		public const string Id = "com.lem00ns.Silksong.Rando";

		public const string Name = "Randomiser";

		public static RandoPlugin instance;

		public static GameManager GM;

		public ModResources resources;

		public SceneLoader sceneLoader;

		public RandoMap map;

		public LogicFile logic;

		public long versionStatus;

		private string versionStatusText;

		private bool versionOutOfDate;

		private string latestVersion;

		public List<CollectableItemPickup> PickupsToIgnore = new List<CollectableItemPickup>();

		public GameModeData GameMode;

		public Dictionary<string, SavedItem> AddressableItems = new Dictionary<string, SavedItem>();

		public bool ShowSceneDebug;

		public List<(string target, string check, SavedItem itm)> CollectableCache = new List<(string, string, SavedItem)>();

		SaveData? ISaveDataMod<SaveData>.SaveData
		{
			get
			{
				return SaveData.Instance;
			}
			set
			{
				SaveData.Instance = value;
			}
		}

		public static ManualLogSource Log => ((BaseUnityPlugin)instance).Logger;

		public Dictionary<string, string> ItemReplacements => SaveData.Instance.ItemReplacements;

		private void Awake()
		{
			instance = this;
			resources = ModResources.LoadResources(((BaseUnityPlugin)this).Logger);
			GameScenes.Load();
			sceneLoader = SceneLoader.Setup();
			map = ((Component)this).gameObject.AddComponent<RandoMap>();
			((Component)this).gameObject.AddComponent<LocationFinder>();
			((Component)this).gameObject.AddComponent<SceneDumper>();
			logic = LogicFile.Load("logic");
			GameMode = GameModeManagerPlugin.Instance.Manager.Init((MonoBehaviour)(object)this, "Randomiser", "Basic randomiser", (Color?)null, false, (Sprite)null);
			MossberryLocation.InstallHooks();
			CollectableItemPickupLocation.InstallHooks();
			VersionInfo.FetchInfo(delegate(long status, string statusText, bool outOfDate, string latest)
			{
				latestVersion = latest;
				versionOutOfDate = outOfDate;
				versionStatusText = statusText;
				versionStatus = status;
			});
		}

		private void Start()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("com.lem00ns.Silksong.Rando").PatchAll(typeof(RandoPlugin).Assembly);
		}

		private void OnGUI()
		{
			//IL_0089: 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_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)GM))
			{
				return;
			}
			GUI.skin.font = ModResources.GetFont();
			List<(string txt, Color color)> DebugTexts = new List<(string, Color)>();
			AddLine("Randomiser by Lem00ns - alpha v0.1.3 - Expect Bugs!");
			if (versionStatus == 0L)
			{
				AddLine("Fetching latest version info...");
			}
			else if (versionStatus == 200)
			{
				if (versionOutOfDate)
				{
					AddColoredLine("Randomiser out of date, latest version is " + latestVersion + " your version is 0.1.3 please update the mod.", Color.red);
				}
			}
			else
			{
				AddColoredLine(versionStatusText, Color.red);
			}
			if (ShowSceneDebug)
			{
				AddLine(GM.GetSceneNameString());
			}
			if (PlayerData.instance != null)
			{
				if (ShowSceneDebug)
				{
					TransitionPoint val = null;
					float num = float.MaxValue;
					foreach (TransitionPoint transitionPoint in TransitionPoint.TransitionPoints)
					{
						Scene scene = ((Component)transitionPoint).gameObject.scene;
						if (((Scene)(ref scene)).name == GM.GetSceneNameString())
						{
							float num2 = Vector2.Distance(Vector2.op_Implicit(((Component)transitionPoint).transform.position), Vector2.op_Implicit(GM.hero_ctrl.transform.position));
							if (num2 < num)
							{
								num = num2;
								val = transitionPoint;
							}
						}
					}
					if ((Object)(object)val != (Object)null)
					{
						AddLine($"{((Object)val).name} - {num}m");
					}
				}
				if (PlayerData.instance.isInventoryOpen)
				{
					AddLine($"{map.mode} map.");
				}
			}
			for (int i = 0; i < DebugTexts.Count; i++)
			{
				GUIStyle labelStyle = ModResources.GetLabelStyle();
				GUI.contentColor = DebugTexts[i].color;
				GUI.Label(new Rect(10f, (float)Screen.height - (40f + (float)(i * 30)), 100f, 100f), DebugTexts[i].txt, labelStyle);
			}
			void AddColoredLine(string txt, Color color)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				DebugTexts.Add((txt, color));
			}
			void AddLine(string txt)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				AddColoredLine(txt, Color.white);
			}
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)GameManager.SilentInstance) && !Object.op_Implicit((Object)(object)GM))
			{
				GM = GameManager.instance;
			}
			if (Input.GetKeyDown((KeyCode)99) && Input.GetKey((KeyCode)292))
			{
				ShowSceneDebug = !ShowSceneDebug;
			}
			if (!Input.GetKeyDown((KeyCode)98) || !Input.GetKey((KeyCode)292))
			{
				return;
			}
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>();
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				try
				{
					dictionary.Add(((Object)allLoadedAssetBundle).name, allLoadedAssetBundle.GetAllAssetNames().ToList());
				}
				catch
				{
				}
			}
			File.WriteAllText(Application.persistentDataPath + "/rando/bundles.json", JsonConvert.SerializeObject((object)dictionary, (Formatting)1));
		}

		private AssetBundle FindBundleContaining(string req)
		{
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				try
				{
					string[] allAssetNames = allLoadedAssetBundle.GetAllAssetNames();
					for (int i = 0; i < allAssetNames.Length; i++)
					{
						if (allAssetNames[i].Contains(req))
						{
							return allLoadedAssetBundle;
						}
					}
				}
				catch
				{
				}
			}
			return null;
		}

		public void LoadFakeCollectables()
		{
			AddressableItems.Clear();
			FakeCollectable[] array = FindBundleContaining("Fake Collectables").LoadAllAssets<FakeCollectable>();
			foreach (FakeCollectable val in array)
			{
				AddressableItems.Add(((Object)val).name, (SavedItem)(object)val);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
		}

		private static SavedItem CreateCollectableItem(string target, string check)
		{
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Expected I4, but got Unknown
			if ((Object)(object)((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).GetByName(target) != (Object)null)
			{
				return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).GetByName(target));
			}
			if ((Object)(object)((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).GetByName(target) != (Object)null)
			{
				return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).GetByName(target));
			}
			if ((Object)(object)CollectableRelicManager.GetRelic(target) != (Object)null)
			{
				return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)CollectableRelicManager.GetRelic(target));
			}
			if (instance.AddressableItems.ContainsKey(target))
			{
				return (SavedItem)(object)RandoItem.Wrap(target, check, instance.AddressableItems[target]);
			}
			if (target.StartsWith("georock_"))
			{
				return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).GetByName("Rosary_Set_Small"));
			}
			RandoItemBuilder randoItemBuilder = RandoItemBuilder.Create(target, check);
			randoItemBuilder.SetDisplayName("Invalid Item");
			randoItemBuilder.SetDescription("Internal Item for the randomiser");
			randoItemBuilder.SetMaxAmount(int.MaxValue);
			if (target.EndsWith(" Map"))
			{
				randoItemBuilder.SetDisplayName(target);
				randoItemBuilder.SetIcon("Map");
			}
			else
			{
				randoItemBuilder.SetIcon("missing");
			}
			RandoItem.OnCollectedCallback onCollectedCallback = null;
			if (target == "Brolly")
			{
				randoItemBuilder.SetDisplayName("Float Cloak");
				randoItemBuilder.SetIcon("DriftersCloak");
				onCollectedCallback = delegate
				{
					GM.playerData.hasBrolly = true;
				};
			}
			if (target == "Faydown")
			{
				randoItemBuilder.SetDisplayName("Faydown Cloak");
				randoItemBuilder.SetIcon("FaydownCloak");
				onCollectedCallback = delegate
				{
					GM.playerData.hasDoubleJump = true;
				};
			}
			if (target == "melody_Vault")
			{
				randoItemBuilder.SetDisplayName("Vaultkeeper's Melody");
				randoItemBuilder.SetIcon("VaultkeepersMelody");
				onCollectedCallback = delegate
				{
					GM.playerData.HasMelodyLibrarian = true;
				};
			}
			if (target == "melody_Conductor")
			{
				randoItemBuilder.SetDisplayName("Conductor's Melody");
				randoItemBuilder.SetIcon("ConductorsMelody");
				onCollectedCallback = delegate
				{
					GM.playerData.HasMelodyConductor = true;
				};
			}
			if (target == "melody_Architect")
			{
				randoItemBuilder.SetDisplayName("Architects's Melody");
				randoItemBuilder.SetIcon("ArchitectsMelody");
				onCollectedCallback = delegate
				{
					GM.playerData.HasMelodyArchitect = true;
				};
			}
			if (target.StartsWith("ability_"))
			{
				WeaverSpireAbility val = Enum.Parse<WeaverSpireAbility>(target.Replace("ability_", ""));
				switch ((int)val)
				{
				case 0:
					return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)ToolItemManager.GetToolByName("Silk Spear"));
				case 8:
					return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)ToolItemManager.GetToolByName("Silk Bomb"));
				case 4:
					return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)ToolItemManager.GetToolByName("Silk Charge"));
				case 2:
					return (SavedItem)(object)RandoItem.Wrap(target, check, (SavedItem)(object)ToolItemManager.GetToolByName("Thread Sphere"));
				case 5:
					randoItemBuilder.SetDisplayName("Clawline");
					randoItemBuilder.SetIcon("Icon_SS_Clawline");
					onCollectedCallback = delegate
					{
						GM.playerData.hasHarpoonDash = true;
					};
					break;
				case 6:
					randoItemBuilder.SetDisplayName("Needolin");
					randoItemBuilder.SetIcon("Icon_SS_Needolin");
					onCollectedCallback = delegate
					{
						GM.playerData.hasNeedolin = true;
					};
					break;
				case 1:
					randoItemBuilder.SetDisplayName("Swift Step");
					randoItemBuilder.SetIcon("Icon_SS_Swift_Step");
					onCollectedCallback = delegate
					{
						GM.playerData.hasDash = true;
					};
					break;
				case 7:
					randoItemBuilder.SetDisplayName("Silk Soar");
					randoItemBuilder.SetIcon("Icon_SS_Silk_Soar");
					onCollectedCallback = delegate
					{
						GM.playerData.hasSuperJump = true;
					};
					break;
				case 3:
					randoItemBuilder.SetDisplayName("Cling Grip");
					randoItemBuilder.SetIcon("Icon_SS_Cling_Grip");
					onCollectedCallback = delegate
					{
						GM.playerData.hasWalljump = true;
					};
					break;
				}
			}
			if (onCollectedCallback != null)
			{
				randoItemBuilder.SetCollectCallback(onCollectedCallback);
			}
			return (SavedItem)(object)randoItemBuilder.Build();
		}

		public static SavedItem GetCollectableItem(string target, string check)
		{
			foreach (var item in instance.CollectableCache)
			{
				if (item.target == target && item.check == check)
				{
					return item.itm;
				}
			}
			SavedItem val = CreateCollectableItem(target, check);
			instance.CollectableCache.Add((target, check, val));
			return val;
		}
	}
	public class SaveData
	{
		private static SaveData? _instance;

		public static SaveData Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new SaveData();
				}
				return _instance;
			}
			[param: AllowNull]
			internal set
			{
				_instance = value;
			}
		}

		public int RandoSeed { get; set; } = -1;


		public Dictionary<string, string> ItemReplacements { get; set; } = new Dictionary<string, string>();


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


		public static void Clear()
		{
			Instance = new SaveData();
		}
	}
	public class SceneLoader : MonoBehaviour
	{
		public delegate void OnSceneCallback(string scene, int index);

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

			private object <>2__current;

			public List<string> scenes;

			public SceneLoader <>4__this;

			public OnSceneCallback OnScene;

			public Action OnComplete;

			private int <i>5__2;

			private string <scn>5__3;

			private AsyncOperationHandle<SceneInstance> <task>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				<scn>5__3 = null;
				<task>5__4 = default(AsyncOperationHandle<SceneInstance>);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				SceneLoader sceneLoader = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log.LogInfo((object)$"Starting task on {scenes.Count} scenes.");
					if (sceneLoader.IsLoading)
					{
						break;
					}
					sceneLoader.IsLoading = true;
					((Component)GameCameras.instance.mainCamera).GetComponent<tk2dCamera>().ZoomFactor = 0.3f;
					TimeManager.TimeScale = 0f;
					Time.timeScale = 0f;
					<i>5__2 = 0;
					goto IL_0169;
				case 1:
					<>1__state = -1;
					goto IL_00ec;
				case 2:
					<>1__state = -1;
					if (OnScene != null)
					{
						OnScene(<scn>5__3, <i>5__2);
					}
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					{
						<>1__state = -1;
						<scn>5__3 = null;
						<task>5__4 = default(AsyncOperationHandle<SceneInstance>);
						<i>5__2++;
						goto IL_0169;
					}
					IL_00ec:
					if (!<task>5__4.IsDone)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
					IL_0169:
					if (<i>5__2 < scenes.Count)
					{
						<scn>5__3 = scenes[<i>5__2];
						<task>5__4 = Addressables.LoadSceneAsync((object)("Scenes/" + <scn>5__3), (LoadSceneMode)0, true, 100, (SceneReleaseMode)0);
						goto IL_00ec;
					}
					TimeManager.TimeScale = 1f;
					Time.timeScale = 1f;
					sceneLoader.IsLoading = false;
					RandoPlugin.GM.ReturnToMainMenuNoSave();
					if (OnComplete != null)
					{
						OnComplete();
					}
					break;
				}
				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();
			}
		}

		public bool IsLoading;

		private static ManualLogSource Log => RandoPlugin.Log;

		public static SceneLoader Setup()
		{
			return ((Component)RandoPlugin.instance).gameObject.AddComponent<SceneLoader>();
		}

		public static void ExecuteLoad(List<string> scenes, OnSceneCallback OnScene, Action? OnComplete = null)
		{
			((MonoBehaviour)RandoPlugin.instance.sceneLoader).StartCoroutine(RandoPlugin.instance.sceneLoader.LoadAll(scenes, OnScene, OnComplete));
		}

		[IteratorStateMachine(typeof(<LoadAll>d__6))]
		public IEnumerator LoadAll(List<string> scenes, OnSceneCallback OnScene, Action? OnComplete = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAll>d__6(0)
			{
				<>4__this = this,
				scenes = scenes,
				OnScene = OnScene,
				OnComplete = OnComplete
			};
		}
	}
	public static class VersionInfo
	{
		public delegate void OnFetched(long status, string statusText, bool outOfDate, string latest);

		private sealed class ProjectInfo
		{
			public string AssemblyTitle;

			public string Version;

			public string GitHubRepo;
		}

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

			private object <>2__current;

			public OnFetched onFetched;

			private UnityWebRequest <request>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<request>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Invalid comparison between Unknown and I4
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
					{
						<>1__state = -1;
						string text = "https://raw.githubusercontent.com/timothymarriott/Silksong-Rando/refs/heads/main/Directory.Build.props";
						<request>5__2 = UnityWebRequest.Get(text);
						<>1__state = -3;
						<request>5__2.timeout = 30;
						<>2__current = <request>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					}
					case 1:
						<>1__state = -3;
						if ((int)<request>5__2.result != 1)
						{
							onFetched(<request>5__2.responseCode, "Failed to fetch latest version error code " + <request>5__2.responseCode, outOfDate: false, "");
							result = false;
						}
						else
						{
							ProjectInfo projectInfo = ParseProjectXml(<request>5__2.downloadHandler.text);
							Version result3;
							if (!Version.TryParse("0.1.3", out Version result2))
							{
								onFetched(0L, "Current version \"0.1.3\" is invalid.", outOfDate: true, projectInfo.Version);
								result = false;
							}
							else if (!Version.TryParse(projectInfo.Version, out result3))
							{
								onFetched(0L, "Latest version \"" + projectInfo.Version + "\" is invalid.", outOfDate: false, projectInfo.Version);
								result = false;
							}
							else
							{
								onFetched(<request>5__2.responseCode, "", result2 < result3, projectInfo.Version);
								result = false;
							}
						}
						<>m__Finally1();
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<request>5__2 != null)
				{
					((IDisposable)<request>5__2).Dispose();
				}
			}

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

		public static void FetchInfo(OnFetched onFetched)
		{
			((MonoBehaviour)RandoPlugin.instance).StartCoroutine(fetchInfo(onFetched));
		}

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

		private static ProjectInfo ParseProjectXml(string xml)
		{
			XElement xElement = XDocument.Parse(xml).Root?.Element("PropertyGroup");
			return new ProjectInfo
			{
				AssemblyTitle = xElement.Element("AssemblyTitle")?.Value,
				Version = xElement.Element("Version")?.Value,
				GitHubRepo = xElement.Element("GitHubRepo")?.Value
			};
		}
	}
}
namespace Silksong.Rando.Data
{
	public static class GameScenes
	{
		public static Dictionary<string, SceneInfo> Scenes = new Dictionary<string, SceneInfo>();

		public static List<string> SceneNames = new List<string>
		{
			"Tut_01", "Tut_01b", "Tut_02", "Tut_03", "Tut_04", "Tut_05", "Mosstown_01", "Mosstown_02", "Mosstown_02c", "Mosstown_03",
			"Aspid_01", "Crawl_01", "Crawl_02", "Crawl_03", "Crawl_03b", "Crawl_04", "Crawl_05", "Crawl_06", "Crawl_07", "Crawl_08",
			"Crawl_09", "Crawl_10", "Belltown", "Belltown_04", "Belltown_06", "Belltown_07", "Belltown_08", "Belltown_Shrine", "Belltown_Room_pinsmith", "Belltown_Room_shellwood",
			"Belltown_Room_doctor", "Belltown_Room_Relic", "Belltown_basement", "Belltown_basement_03", "Bellway_01", "Bellway_01_boss", "Bellway_02", "Bellway_02_boss", "Bellway_03", "Bellway_03_boss",
			"Bellway_04", "Bellway_04_boss", "Bellway_08", "Bellway_City", "Bellway_Peak", "Bellway_Peak_02", "Bellway_Shadow", "Bellway_Aqueduct", "Bellway_Centipede_Arena", "Bellway_Centipede_additive",
			"Bellshrine", "Bellshrine_02", "Bellshrine_03", "Bellshrine_05", "Bellshrine_Enclave", "Bellshrine_Coral", "Bellshrine_Lore_Additive", "Bonetown", "Bonegrave", "Bone_01",
			"Bone_01b", "Bone_01c", "Bone_02", "Bone_03", "Bone_04", "Bone_05", "Bone_05_boss", "Bone_05_bellway", "Bone_05b", "Bone_06",
			"Bone_07", "Bone_08", "Bone_09", "Bone_10", "Bone_11", "Bone_11b", "Bone_12", "Bone_14", "Bone_15", "Bone_16",
			"Bone_17", "Bone_18", "Bone_19", "Ant_02", "Ant_03", "Ant_04", "Ant_04_mid", "Ant_04_left", "Ant_05b", "Ant_05c",
			"Ant_08", "Ant_09", "Ant_14", "Ant_17", "Ant_19", "Ant_20", "Ant_21", "Ant_Merchant", "Ant_Queen", "Dock_01",
			"Dock_02", "Dock_02b", "Dock_03", "Dock_03b", "Dock_03c", "Dock_03d", "Dock_04", "Dock_05", "Dock_06_Church", "Dock_08",
			"Dock_09", "Dock_10", "Dock_11", "Dock_12", "Dock_13", "Dock_14", "Dock_15", "Dock_16", "Room_Forge", "Bone_East_01",
			"Bone_East_02", "Bone_East_02b", "Bone_East_03", "Bone_East_04", "Bone_East_04c", "Bone_East_04b", "Bone_East_05", "Bone_East_07", "Bone_East_08", "Bone_East_09",
			"Bone_East_09b", "Bone_East_10", "Bone_East_10_Church", "Bone_East_10_Room", "Bone_East_11", "Bone_East_12", "Bone_East_13", "Bone_East_14", "Bone_East_14b", "Bone_East_15",
			"Bone_East_16", "Bone_East_17", "Bone_East_17b", "Bone_East_18", "Bone_East_18b", "Bone_East_18c", "Bone_East_20", "Bone_East_21", "Bone_East_22", "Bone_East_24",
			"Bone_East_25", "Bone_East_Weavehome", "Bone_East_Umbrella", "Bone_East_LavaChallenge", "Halfway_01", "Greymoor_01", "Greymoor_02", "Greymoor_03", "Greymoor_04", "Greymoor_05",
			"Greymoor_05_boss", "Greymoor_06", "Greymoor_07", "Greymoor_08", "Greymoor_08_boss", "Greymoor_08_caravan", "Greymoor_08_mapper", "Greymoor_10", "Greymoor_11", "Greymoor_12",
			"Greymoor_13", "Greymoor_15", "Greymoor_15b", "Greymoor_16", "Greymoor_17", "Greymoor_20b", "Greymoor_20c", "Greymoor_21", "Greymoor_22", "Greymoor_24",
			"Dust_01", "Dust_02", "Dust_03", "Dust_04", "Dust_05", "Dust_06", "Dust_09", "Dust_10", "Dust_11", "Dust_12",
			"Dust_Barb", "Dust_Shack", "Dust_Chef", "Dust_Maze_01", "Dust_Maze_02", "Dust_Maze_03", "Dust_Maze_04", "Dust_Maze_05", "Dust_Maze_06", "Dust_Maze_07",
			"Dust_Maze_08", "Dust_Maze_crossing", "Dust_Maze_Last_Hall", "Dust_Maze_08_completed", "Dust_Maze_09_entrance", "Organ_01", "Shadow_01", "Shadow_02", "Shadow_03", "Shadow_04",
			"Shadow_04b", "Shadow_05", "Shadow_09", "Shadow_10", "Shadow_11", "Shadow_12", "Shadow_13", "Shadow_14", "Shadow_15", "Shadow_16",
			"Shadow_18", "Shadow_19", "Shadow_20", "Shadow_21", "Shadow_22", "Shadow_23", "Shadow_24", "Shadow_25", "Shadow_26", "Shadow_27",
			"Shadow_28", "Shadow_Weavehome", "Aqueduct_01", "Aqueduct_02", "Aqueduct_03", "Aqueduct_04", "Aqueduct_05", "Aqueduct_06", "Aqueduct_07", "Wisp_02",
			"Wisp_03", "Wisp_04", "Wisp_05", "Wisp_06", "Wisp_07", "Wisp_08", "Wisp_09", "Shellwood_01", "Shellwood_01b", "Shellwood_02",
			"Shellwood_03", "Shellwood_04b", "Shellwood_04c", "Shellwood_08", "Shellwood_08c", "Shellwood_10", "Shellwood_11", "Shellwood_11b", "Shellwood_13", "Shellwood_14",
			"Shellwood_15", "Shellwood_16", "Shellwood_18", "Shellwood_19", "Shellwood_20", "Shellwood_22", "Shellwood_25", "Shellwood_25b", "Shellwood_26", "Shellwood_Witch",
			"Shellwood_11b_Memory", "Shellgrave", "Coral_02", "Coral_03", "Coral_10", "Coral_11", "Coral_11b", "Coral_12", "Coral_19", "Coral_19b",
			"Coral_23", "Coral_24", "Coral_25", "Coral_26", "Coral_27", "Coral_28", "Coral_29", "Coral_32", "Coral_33", "Coral_34",
			"Coral_35", "Coral_35b", "Coral_36", "Coral_37", "Coral_38", "Coral_39", "Coral_40", "Coral_41", "Coral_42", "Coral_43",
			"Coral_Tower_01", "Coral_Judge_Arena", "Under_01", "Under_01b", "Under_02", "Under_03", "Under_03b", "Under_03c", "Under_03d", "Under_04",
			"Under_05", "Under_06", "Under_07", "Under_07b", "Under_07c", "Under_08", "Under_10", "Under_11", "Under_12", "Under_13",
			"Under_14", "Under_16", "Under_17", "Under_18", "Under_19", "Under_19b", "Under_19c", "Under_20", "Under_21", "Under_22",
			"Under_23", "Song_01", "Song_01b", "Song_01c", "Song_02", "Song_03", "Song_04", "Song_05", "Song_07", "Song_08",
			"Song_09", "Song_09b", "Song_10", "Song_11", "Song_12", "Song_13", "Song_14", "Song_15", "Song_17", "Song_18",
			"Song_19_entrance", "Song_20", "Song_20b", "Song_24", "Song_25", "Song_26", "Song_27", "Song_Enclave", "Song_Enclave_Tube", "Tube_Hub",
			"Ward_01", "Ward_02", "Ward_02b", "Ward_03", "Ward_04", "Ward_05", "Ward_06", "Ward_07", "Library_01", "Library_02",
			"Library_03", "Library_04", "Library_05", "Library_06", "Library_07", "Library_08", "Library_09", "Library_10", "Library_11", "Library_11b",
			"Library_12", "Library_12b", "Library_13", "Library_13b", "Library_14", "Library_15", "Library_16", "Hang_01", "Hang_02", "Hang_03",
			"Hang_03_top", "Hang_04", "Hang_06", "Hang_06b", "Hang_06_bank", "Hang_07", "Hang_08", "Hang_09", "Hang_10", "Hang_12",
			"Hang_13", "Hang_14", "Hang_15", "Hang_16", "Hang_17b", "Arborium_01", "Arborium_02", "Arborium_03", "Arborium_04", "Arborium_05",
			"Arborium_06", "Arborium_07", "Arborium_08", "Arborium_09", "Arborium_10", "Arborium_11", "Arborium_Tube", "Cog_04", "Cog_05", "Cog_06",
			"Cog_07", "Cog_08", "Cog_09", "Cog_10", "Cog_Bench", "Cog_Pass", "Cog_Dancers", "Cog_Dancers_boss", "Cradle_01", "Cradle_02",
			"Cradle_03", "Song_Tower_01", "Song_Tower_Destroyed", "Cog_09_Destroyed", "Cog_10_Destroyed", "Cradle_01_Destroyed", "Cradle_03_Destroyed", "Cradle_Destroyed_Challenge_Bench", "Cradle_Destroyed_Challenge_01", "Abandoned_town",
			"Slab_01", "Slab_02", "Slab_03", "Slab_04", "Slab_05", "Slab_06", "Slab_07", "Slab_08", "Slab_10b", "Slab_10c",
			"Slab_12", "Slab_13", "Slab_14", "Slab_15", "Slab_16", "Slab_17", "Slab_18", "Slab_19b", "Slab_20", "Slab_21",
			"Slab_22", "Slab_23", "Slab_Cell", "Slab_Cell_Creature", "Slab_Cell_Quiet", "Peak_01", "Peak_02", "Peak_04", "Peak_04c", "Peak_04d",
			"Peak_05", "Peak_05c", "Peak_05d", "Peak_05e", "Peak_06", "Peak_07", "Peak_08", "Peak_08b", "Peak_10", "Peak_12",
			"Peak_Mask_Maker", "Weave_02", "Weave_03", "Weave_04", "Weave_05b", "Weave_07", "Weave_08", "Weave_10", "Weave_11", "Weave_12",
			"Weave_13", "Weave_14", "Clover_01", "Clover_01b", "Clover_02c", "Clover_03", "Clover_04b", "Clover_05c", "Clover_06", "Clover_10",
			"Clover_10_web", "Clover_11", "Clover_16", "Clover_18", "Clover_19", "Clover_20", "Abyss_01", "Abyss_02", "Abyss_02b", "Abyss_03",
			"Abyss_04", "Abyss_05", "Abyss_06", "Abyss_07", "Abyss_08", "Abyss_09", "Abyss_11", "Abyss_12", "Abyss_13", "Bonetown_boss",
			"Room_CrowCourt", "Room_CrowCourt_02", "Room_Pinstress", "Room_Witch", "Room_Caravan_Spa", "Room_Caravan_Interior", "Room_Huntress", "Room_Diving_Bell", "Room_Diving_Bell_Abyss", "Room_Diving_Bell_Abyss_Fixed",
			"Sprintmaster_Cave", "City_Lace_cutscene", "Chapel_Wanderer", "Memory_Needolin", "Memory_First_Sinner", "Memory_Silk_Heart_BellBeast", "Memory_Silk_Heart_WardBoss", "Memory_Silk_Heart_LaceTower", "Memory_Coral_Tower", "Memory_Ant_Queen",
			"Belltown_Room_Spare", "Shadow_08", "Cradle_02b", "Slab_16b", "Clover_21", "Pre_Menu_Loader", "Bone_East_08_boss_golem", "Bone_East_08_boss_golem_rest", "Bone_East_08_boss_beastfly", "Song_28",
			"Song_29", "Aqueduct_08", "Coral_44", "Hang_04_boss", "Shadow_Bilehaven_Room", "Abyss_Cocoon", "Peak_06b", "Bone_East_26", "Bone_East_27", "Memory_Red",
			"Ward_09", "Bone_Steel_Servant", "Cradle_Destroyed_Challenge_02", "Under_27", "Ward_02_boss"
		};

		public static void Load()
		{
			Dictionary<string, SceneInfo> dictionary = JsonConvert.DeserializeObject<Dictionary<string, SceneInfo>>(ModResources.LoadData("scenes"));
			if (dictionary != null)
			{
				Scenes = dictionary;
			}
		}
	}
}
namespace Silksong.Rando.Data.Extractors
{
	[Serializable]
	public class SceneInfo
	{
		public float width;

		public float height;

		public Vector2 Size => new Vector2(width, height);
	}
	public class SceneDumper : MonoBehaviour
	{
		private void Update()
		{
			if (!Input.GetKeyDown((KeyCode)115) || !Input.GetKey((KeyCode)292))
			{
				return;
			}
			RandoPlugin.Log.LogInfo((object)"Starting to laod scene sizes");
			Dictionary<string, SceneInfo> sceneSizes = new Dictionary<string, SceneInfo>();
			SceneLoader.ExecuteLoad(GameScenes.SceneNames, delegate(string scene, int i)
			{
				RandoPlugin.Log.LogInfo((object)$"Searching {scene} ({i}/{GameScenes.SceneNames.Count})");
				try
				{
					sceneSizes.Add(scene, new SceneInfo
					{
						width = RandoPlugin.GM.tilemap.width,
						height = RandoPlugin.GM.tilemap.height
					});
				}
				catch (Exception ex)
				{
					RandoPlugin.Log.LogError((object)ex);
				}
			}, delegate
			{
				File.WriteAllText(Application.persistentDataPath + "\\rando\\scenes.json", JsonConvert.SerializeObject((object)sceneSizes, (Formatting)1));
			});
		}
	}
}
namespace Silksong.Rando.Map
{
	public enum MapMode
	{
		No,
		Checks,
		Dev,
		Spoiler
	}
	public class RandoMap : MonoBehaviour
	{
		public enum PinColor
		{
			Black,
			Red,
			Yellow,
			White,
			Bronze
		}

		public static RandoMap instance;

		public List<GameObject> CreatedMarkers = new List<GameObject>();

		public MapMode mode;

		public static GameManager GM => RandoPlugin.GM;

		private void Awake()
		{
			instance = this;
			PlayerDataVariableEvents.OnGetBool += delegate(PlayerData pd, string fieldName, bool current)
			{
				if (fieldName == "mapAllRooms")
				{
					return true;
				}
				return fieldName == "hasQuill" || current;
			};
		}

		private void Update()
		{
			if (PlayerData.instance != null && Input.GetKeyDown((KeyCode)116) && PlayerData.instance.isInventoryOpen)
			{
				mode = (MapMode)((int)(mode + 1) % 4);
				Refresh();
			}
			if (Input.GetKeyDown((KeyCode)114) && Input.GetKey((KeyCode)292))
			{
				int num = Random.Range(0, int.MaxValue);
				RandoPlugin.Log.LogInfo((object)$"Starting rando with seed {num}");
				SaveData.Instance.RandoSeed = num;
				SaveData.Instance.ItemReplacements = RandoPlugin.instance.logic.GenerateSeed(num);
				Refresh();
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
		}

		public void Refresh()
		{
			foreach (GameObject createdMarker in CreatedMarkers)
			{
				Object.Destroy((Object)(object)createdMarker);
			}
			CreateLocationPins();
		}

		public void CreateMapPin(ItemLocationData loc)
		{
			//IL_0041: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			if (mode == MapMode.Checks && !RandoPlugin.instance.logic.HasCheck(loc.GetID()))
			{
				return;
			}
			GameMapScene val = default(GameMapScene);
			GameObject val2 = default(GameObject);
			Vector2 val3 = default(Vector2);
			GM.gameMap.GetSceneInfo(loc.scene, GM.gameMap.GetMapZoneFromSceneName(loc.scene), ref val, ref val2, ref val3);
			Vector2 mapPosition = GM.gameMap.GetMapPosition(loc.PositionInScene, val, val2, val3, GameScenes.Scenes[loc.scene].Size);
			Transform val4 = GM.gameMap.compassIcon.transform.parent;
			for (int i = 0; i < GM.gameMap.compassIcon.transform.parent.childCount; i++)
			{
				if (((Object)((Component)GM.gameMap.compassIcon.transform.parent.GetChild(i)).gameObject).name == "Map Markers")
				{
					val4 = GM.gameMap.compassIcon.transform.parent.GetChild(i);
				}
			}
			PinColor pinColor = PinColor.Black;
			if (RandoPlugin.instance.logic.HasCheck(loc.GetID()))
			{
				pinColor = PinColor.White;
			}
			GameObject val5 = Object.Instantiate<GameObject>(((Component)val4.GetChild((int)pinColor)).gameObject, val4);
			CreatedMarkers.Add(val5);
			val5.transform.localScale = Vector3.one * 0.4f;
			SpriteRenderer component = val5.GetComponent<SpriteRenderer>();
			if (mode == MapMode.Dev)
			{
				if (SaveData.Instance.ItemReplacements.ContainsKey(loc.GetID()))
				{
					SavedItem collectableItem = RandoPlugin.GetCollectableItem(loc.item, loc.GetID());
					component.sprite = collectableItem.GetPopupIcon();
				}
				else
				{
					SavedItem collectableItem2 = RandoPlugin.GetCollectableItem(loc.item, loc.GetID());
					component.sprite = collectableItem2.GetPopupIcon();
					component.color = Color.green;
				}
				if (!RandoPlugin.instance.logic.HasCheck(loc.scene + "|" + loc.item))
				{
					component.color = Color.red;
				}
			}
			if (mode == MapMode.Spoiler)
			{
				if (SaveData.Instance.ItemReplacements.ContainsKey(loc.GetID()))
				{
					SavedItem collectableItem3 = RandoPlugin.GetCollectableItem(SaveData.Instance.ItemReplacements[loc.GetID()], loc.GetID());
					component.sprite = collectableItem3.GetPopupIcon();
				}
				else
				{
					SavedItem collectableItem4 = RandoPlugin.GetCollectableItem(loc.item, loc.GetID());
					component.sprite = collectableItem4.GetPopupIcon();
				}
			}
			if (mode == MapMode.Checks)
			{
				SavedItem collectableItem5 = RandoPlugin.GetCollectableItem(loc.item, loc.GetID());
				component.sprite = collectableItem5.GetPopupIcon();
			}
			if (SaveData.Instance.CollectedChecks.Contains(loc.GetID()))
			{
				component.color *= new Color(1f, 1f, 1f, 0.5f);
			}
			Extensions.SetLocalPosition2D(val5.transform, Vector2.op_Implicit(new Vector3(mapPosition.x, mapPosition.y, -1f)));
			if (!val5.activeSelf)
			{
				val5.SetActive(true);
			}
		}

		public void CreateLocationPins()
		{
			if (mode == MapMode.No)
			{
				return;
			}
			foreach (var (_, loc) in JsonConvert.DeserializeObject<Dictionary<string, ItemLocationData>>(ModResources.LoadData("locations")))
			{
				CreateMapPin(loc);
			}
		}
	}
}
namespace Silksong.Rando.Map.Hooks
{
	[HarmonyPatch(typeof(GameMap), "Start")]
	internal class GameMap_Start_Patch
	{
		public static void Postfix(GameMap __instance)
		{
			RandoMap.instance.CreateLocationPins();
			RandoPlugin.GM.UpdateGameMapWithPopup(0f);
		}
	}
}
namespace Silksong.Rando.Logic
{
	[Serializable]
	public class LogicFile
	{
		[CompilerGenerated]
		private sealed class <ParseReq>d__8 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string req;

			public string <>3__req;

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

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

			[DebuggerHidden]
			public <ParseReq>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (string.IsNullOrWhiteSpace(req) || req == "true")
					{
						return false;
					}
					<>2__current = req;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<ParseReq>d__8 <ParseReq>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ParseReq>d__ = this;
				}
				else
				{
					<ParseReq>d__ = new <ParseReq>d__8(0);
				}
				<ParseReq>d__.req = <>3__req;
				return <ParseReq>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		public string start;

		public string[] required;

		public Dictionary<string, LogicNode> nodes;

		[JsonIgnore]
		public LogicNode StartNode => nodes[start];

		public static LogicFile Load(string name)
		{
			return JsonConvert.DeserializeObject<LogicFile>(ModResources.LoadData(name));
		}

		public bool HasCheck(string id)
		{
			foreach (var (_, logicNode2) in nodes)
			{
				if (logicNode2.checks == null)
				{
					continue;
				}
				string[] checks = logicNode2.checks;
				for (int i = 0; i < checks.Length; i++)
				{
					if (checks[i] == id)
					{
						return true;
					}
				}
			}
			return false;
		}

		public Dictionary<string, string> GenerateSeed(int seed = -1)
		{
			Random rng = new Random();
			if (seed != -1)
			{
				rng = new Random(seed);
			}
			Dictionary<string, ItemLocationData>.KeyCollection keys = JsonConvert.DeserializeObject<Dictionary<string, ItemLocationData>>(ModResources.LoadData("locations")).Keys;
			Dictionary<string, string> placements = new Dictionary<string, string>();
			HashSet<string> reachable = new HashSet<string> { start };
			Dictionary<string, List<string>> nodeChecks = new Dictionary<string, List<string>>();
			string[] checks;
			foreach (KeyValuePair<string, LogicNode> node in nodes)
			{
				node.Deconstruct(out var key, out var value);
				string key2 = key;
				LogicNode logicNode = value;
				List<string> list = new List<string>();
				if (logicNode.checks != null)
				{
					checks = logicNode.checks;
					foreach (string text in checks)
					{
						if (keys.Contains(text))
						{
							list.Add(text);
						}
					}
				}
				Shuffle(list, rng);
				nodeChecks[key2] = list;
			}
			HashSet<string> obtainedItems = new HashSet<string>();
			HashSet<string> hashSet = new HashSet<string>();
			foreach (List<string> value2 in nodeChecks.Values)
			{
				foreach (string item2 in value2)
				{
					hashSet.Add(item2.Split('|')[1]);
				}
			}
			bool progress2;
			do
			{
				progress2 = false;
				while (true)
				{
					IL_019a:
					RefreshReachable(ref progress2);
					checks = reachable.ToArray();
					foreach (string key3 in checks)
					{
						NodeEdge[] array = nodes[key3].edges ?? Array.Empty<NodeEdge>();
						foreach (NodeEdge nodeEdge in array)
						{
							if (reachable.Contains(nodeEdge.to))
							{
								continue;
							}
							foreach (string item3 in ParseReq(nodeEdge.req))
							{
								if (!obtainedItems.Contains(item3))
								{
									ForcePlaceItem(item3, placements, nodes[key3].checks.ToList(), rng);
									obtainedItems.Add(item3);
									progress2 = true;
									goto IL_019a;
								}
							}
						}
					}
					break;
				}
				RefreshReachable(ref progress2);
			}
			while (progress2);
			if (reachable.Count != nodes.Count)
			{
				throw new Exception("Unreachable nodes remain after placement");
			}
			checks = required;
			foreach (string text2 in checks)
			{
				placements[GetReachableChecks(ref progress2)[0]] = text2;
				obtainedItems.Add(text2);
			}
			List<string> list2 = new List<string>();
			foreach (KeyValuePair<string, LogicNode> node2 in nodes)
			{
				checks = node2.Value.checks;
				for (int i = 0; i < checks.Length; i++)
				{
					string item = checks[i].Split("|", 2)[1];
					if (!obtainedItems.Contains(item))
					{
						list2.Add(item);
					}
				}
			}
			foreach (string reachableCheck in GetReachableChecks(ref progress2))
			{
				if (!placements.ContainsKey(reachableCheck))
				{
					if (list2.Count > 0)
					{
						placements[reachableCheck] = list2[0];
						obtainedItems.Add(list2[0]);
						list2.RemoveAt(0);
					}
					else
					{
						RandoPlugin.Log.LogWarning((object)"Ran out of items");
					}
				}
			}
			return placements;
			List<string> GetReachableChecks(ref bool progress)
			{
				List<string> list3 = new List<string>();
				RefreshReachable(ref progress);
				string[] array2 = reachable.ToArray();
				foreach (string key4 in array2)
				{
					foreach (string item4 in nodeChecks[key4])
					{
						if (!placements.ContainsKey(item4))
						{
							list3.Add(item4);
						}
					}
				}
				Shuffle(list3, rng);
				return list3;
			}
			void RefreshReachable(ref bool progress)
			{
				string[] array3 = reachable.ToArray();
				foreach (string key5 in array3)
				{
					NodeEdge[] array4 = nodes[key5].edges ?? Array.Empty<NodeEdge>();
					foreach (NodeEdge nodeEdge2 in array4)
					{
						if (!reachable.Contains(nodeEdge2.to) && EdgeSatisfied(nodeEdge2, obtainedItems))
						{
							reachable.Add(nodeEdge2.to);
							progress = true;
						}
					}
				}
			}
		}

		[IteratorStateMachine(typeof(<ParseReq>d__8))]
		private static IEnumerable<string> ParseReq(string? req)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ParseReq>d__8(-2)
			{
				<>3__req = req
			};
		}

		private static bool ForcePlaceItem(string item, Dictionary<string, string> placements, List<string> reachable, Random rng)
		{
			foreach (string item2 in Shuffled(reachable, rng))
			{
				if (!placements.ContainsKey(item2))
				{
					placements[item2] = item;
					RandoPlugin.Log.LogInfo((object)("Force placed " + item));
					return true;
				}
			}
			return false;
		}

		private static bool EdgeSatisfied(NodeEdge edge, HashSet<string> obtainedItems)
		{
			if (string.IsNullOrWhiteSpace(edge.req) || edge.req == "true")
			{
				return true;
			}
			if (!obtainedItems.Contains(edge.req))
			{
				return false;
			}
			return true;
		}

		private static void Shuffle<T>(IList<T> list, Random rng)
		{
			for (int num = list.Count - 1; num > 0; num--)
			{
				int num2 = rng.Next(num + 1);
				int index = num;
				int index2 = num2;
				T value = list[num2];
				T value2 = list[num];
				list[index] = value;
				list[index2] = value2;
			}
		}

		private static IList<T> Shuffled<T>(IList<T> list, Random rng)
		{
			List<T> list2 = list.ToList();
			Shuffle(list2, rng);
			return list2;
		}
	}
	[Serializable]
	public class LogicNode
	{
		public NodeEdge[] edges;

		public string[] checks;
	}
	[Serializable]
	public class NodeEdge
	{
		public string to;

		public string req = "true";
	}
}
namespace Silksong.Rando.Locations
{
	public class BrollyLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public BrollyLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "Brolly";
		}

		public override void SetItem(string item)
		{
			//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)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			FsmState state = FsmUtil.GetState(fsm, "Msg");
			FsmUtil.RemoveAction(state, 3);
			FsmUtil.RemoveAction(state, 2);
			FsmUtil.RemoveAction(state, 1);
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmUtil.AddLambdaMethod(state, (Action<Action>)delegate(Action fin)
			{
				AwardCollectable();
				fin();
			});
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmUtil.RemoveTransitionsTo(state, "Fade Up");
			FsmUtil.AddTransition(state, "FINISHED", "Fade Up");
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	public class CollectableItemPickupLocation : ItemLocation
	{
		private CollectableItemPickup pickup;

		public CollectableItemPickupLocation(CollectableItemPickup pickup)
		{
			this.pickup = pickup;
		}

		public override string GetItem()
		{
			return ((Object)pickup.item).name;
		}

		public override GameObject GetObj()
		{
			return ((Component)pickup).gameObject;
		}

		public override void SetItem(string item)
		{
			if (IsChecked())
			{
				Object.Destroy((Object)(object)((Component)pickup).gameObject);
			}
			else
			{
				pickup.SetItem(RandoPlugin.GetCollectableItem(item, GetLocationID()), false);
			}
		}

		public static void InstallHooks()
		{
			PlayerDataVariableEvents.OnGetInt += (PlayerData pd, string name, int current) => (name == "dicePilgrimState" && RandoPlugin.instance.GameMode.Enabled) ? 1 : current;
		}
	}
	public class DJLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public DJLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "Faydown";
		}

		public override void SetItem(string item)
		{
			//IL_0073: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			FsmState checkState = FsmUtil.GetState(fsm, "Has DJ?");
			FsmUtil.RemoveAction(checkState, 0);
			FsmUtil.AddLambdaMethod(checkState, (Action<Action>)delegate
			{
				if (IsChecked())
				{
					fsm.Fsm.Event(checkState.GetTransitionEvent(0));
				}
				else
				{
					fsm.Fsm.Event(checkState.GetTransitionEvent(1));
				}
			});
			FsmState state = FsmUtil.GetState(fsm, "Msg");
			FsmUtil.RemoveAction(state, 13);
			FsmUtil.RemoveAction(state, 12);
			FsmUtil.RemoveAction(state, 11);
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmUtil.AddLambdaMethod(state, (Action<Action>)delegate(Action fin)
			{
				AwardCollectable();
				fin();
			});
			FsmUtil.RemoveTransitionsTo(state, "Fade Back Pause");
			FsmUtil.AddTransition(state, "FINISHED", "Fade Back Pause");
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	public class GeoRockLocation : ItemLocation
	{
		private GeoRock rock;

		public GeoRockLocation(GeoRock rock)
		{
			this.rock = rock;
		}

		public override string GetItem()
		{
			//IL_0020: 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)
			string id = rock.geoRockData.id;
			BreakableTypes breakableType = rock.BreakableType;
			return "georock_" + id + "_" + ((object)(BreakableTypes)(ref breakableType)).ToString();
		}

		public override GameObject GetObj()
		{
			return ((Component)rock).gameObject;
		}

		public override void SetItem(string item)
		{
			base.SetItem(item);
			Object.Destroy((Object)(object)((Component)rock).gameObject);
		}
	}
	public class HeartPieceLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public HeartPieceLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "Heart Piece";
		}

		public override void SetItem(string item)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			Object.Destroy((Object)(object)((Component)fsm).gameObject.GetComponent<PersistentBoolItem>());
			FsmState state = FsmUtil.GetState(fsm, "UI");
			FsmUtil.RemoveAction(state, 1);
			FsmUtil.RemoveAction(state, 0);
			FsmUtil.AddAction(state, (FsmStateAction)(object)FsmUtil.GetAction<RemoveHeroInputBlocker>(FsmUtil.GetState(fsm, "End"), 0));
			FsmUtil.AddAction(state, FsmUtil.GetAction<FsmStateAction>(FsmUtil.GetState(fsm, "End"), 1));
			FsmUtil.AddAction(state, (FsmStateAction)new SendEventToRegister
			{
				eventName = FsmString.op_Implicit("HEART PIECE COLLECTED")
			});
			FsmUtil.AddLambdaMethod(state, (Action<Action>)delegate(Action fin)
			{
				AwardCollectable();
				PlayerData.instance.isInvincible = false;
				PlayerData.instance.disablePause = false;
				HeroController.instance.StartAnimationControl();
				HeroController.instance.RegainControl();
				HeroController.instance.AffectedByGravity(true);
				HeroController.instance.rb2d.gravityScale = HeroController.instance.DEFAULT_GRAVITY;
				HeroController.instance.currentGravity = HeroController.instance.DEFAULT_GRAVITY;
				HeroController.instance.prevGravityScale = 0f;
				fin();
			});
			FsmUtil.RemoveState(fsm, "Save Collected");
			FsmUtil.RemoveTransitions(state);
			FsmUtil.AddTransition(state, "FINISHED", "End");
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	[Serializable]
	public class ItemLocationData
	{
		public string locationType;

		public string item;

		public string scene;

		public float positionInSceneX;

		public float positionInSceneY;

		public Vector2 PositionInScene => new Vector2(positionInSceneX, positionInSceneY);

		public string GetID()
		{
			return scene + "|" + item;
		}
	}
	public abstract class ItemLocation
	{
		public ItemLocationData locationData = new ItemLocationData();

		private string replacement;

		public abstract string GetItem();

		public string GetLocationID()
		{
			return RandoPlugin.GM.sceneName + "|" + GetItem();
		}

		public void AddToCurrentScene()
		{
			//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_0049: 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)
			locationData.locationType = GetType().Name;
			locationData.item = GetItem();
			locationData.scene = RandoPlugin.GM.sceneName;
			Vector2 position = GetPosition();
			locationData.positionInSceneX = position.x;
			locationData.positionInSceneY = position.y;
			if (LocationFinder.IsSearching)
			{
				LocationFinder.ItemLocations.TryAdd(GetLocationID(), this);
			}
			if (RandoPlugin.instance.GameMode.Enabled && RandoPlugin.instance.ItemReplacements.ContainsKey(GetLocationID()))
			{
				if (!SaveData.Instance.CollectedChecks.Contains(GetLocationID()))
				{
					SetReplacement(RandoPlugin.instance.ItemReplacements[GetLocationID()]);
				}
				else
				{
					SetReplacement("Already Collected");
				}
			}
		}

		public void SetReplacement(string id)
		{
			replacement = id;
			RandoPlugin.Log.LogInfo((object)(GetLocationID() + " -> " + ((RandoPlugin.instance.map.mode == MapMode.Spoiler) ? replacement : "SPOILERS") + (IsChecked() ? " checked" : " unchecked")));
			SetItem(id);
		}

		public virtual Vector2 GetPosition()
		{
			//IL_000b: 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)
			return Vector2.op_Implicit(GetObj().transform.position);
		}

		public abstract GameObject GetObj();

		public virtual void SetItem(string item)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!IsChecked())
			{
				((Component)CreateItemPickup(item)).transform.position = GetObj().transform.position;
			}
		}

		public void AwardCollectable()
		{
			if (!IsChecked())
			{
				RandoPlugin.GetCollectableItem(replacement, GetLocationID()).Get(1, true);
			}
		}

		public bool IsChecked()
		{
			return SaveData.Instance.CollectedChecks.Contains(GetLocationID());
		}

		public CollectableItemPickup CreateItemPickup(string item)
		{
			CollectableItemPickup component = Object.Instantiate<GameObject>(((Component)Gameplay.CollectableItemPickupPrefab).gameObject).GetComponent<CollectableItemPickup>();
			RandoPlugin.instance.PickupsToIgnore.Add(component);
			component.SetItem(RandoPlugin.GetCollectableItem(item, GetLocationID()), false);
			return component;
		}
	}
	public class LocationFinder : MonoBehaviour
	{
		public static Dictionary<string, ItemLocation> ItemLocations = new Dictionary<string, ItemLocation>();

		public static Dictionary<string, Dictionary<string, Dictionary<string, string>>> RoomChecks = new Dictionary<string, Dictionary<string, Dictionary<string, string>>>();

		public static bool IsSearching = false;

		private void Update()
		{
			if (!Input.GetKeyDown((KeyCode)121) || !Input.GetKey((KeyCode)292) || IsSearching)
			{
				return;
			}
			IsSearching = true;
			SceneLoader.ExecuteLoad(GameScenes.SceneNames, delegate(string scene, int i)
			{
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				RandoPlugin.Log.LogInfo((object)$"Searching {scene} ({i}/{GameScenes.SceneNames.Count}) found {ItemLocations.Count} locations.");
				File.WriteAllLines(Application.persistentDataPath + "\\rando\\locations.txt", ItemLocations.Keys);
				Dictionary<string, ItemLocationData> dictionary = new Dictionary<string, ItemLocationData>();
				foreach (KeyValuePair<string, ItemLocation> itemLocation in ItemLocations)
				{
					dictionary.Add(itemLocation.Key, itemLocation.Value.locationData);
				}
				File.WriteAllText(Application.persistentDataPath + "\\rando\\locations.json", JsonConvert.SerializeObject((object)dictionary, (Formatting)1));
				List<string> list = new List<string>();
				foreach (TransitionPoint transitionPoint in TransitionPoint.TransitionPoints)
				{
					Scene scene2 = ((Component)transitionPoint).gameObject.scene;
					if (((Scene)(ref scene2)).name == scene)
					{
						list.Add(((Object)transitionPoint).name);
					}
				}
				Dictionary<string, Dictionary<string, string>> dictionary2 = new Dictionary<string, Dictionary<string, string>>();
				foreach (string item in list)
				{
					Dictionary<string, string> dictionary3 = new Dictionary<string, string>();
					foreach (string item2 in list)
					{
						dictionary3.Add(item2, "TRANSITION_NOTSET");
					}
					foreach (KeyValuePair<string, ItemLocation> itemLocation2 in ItemLocations)
					{
						if (itemLocation2.Value.locationData.scene == scene)
						{
							dictionary3.Add(itemLocation2.Value.locationData.item, "ITEM_NOTSET");
						}
					}
					dictionary2.Add(item, dictionary3);
				}
				RoomChecks.Add(scene, dictionary2);
				File.WriteAllText(Application.persistentDataPath + "\\rando\\room_logic.json", JsonConvert.SerializeObject((object)RoomChecks, (Formatting)1));
			}, delegate
			{
				IsSearching = false;
			});
		}
	}
	public class ArchitectMelodyLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public ArchitectMelodyLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "melody_Architect";
		}

		public override void SetItem(string item)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			bool num = IsChecked();
			FsmState state = FsmUtil.GetState(fsm, "Wait For Notify");
			if (num)
			{
				FsmUtil.GetAction<PlayerDataVariableTest>(state, 0).IsExpectedEvent = state.GetTransitionEvent(2);
				FsmUtil.GetAction<PlayerDataVariableTest>(state, 0).IsNotExpectedEvent = state.GetTransitionEvent(2);
			}
			else
			{
				FsmUtil.GetAction<PlayerDataVariableTest>(state, 0).IsExpectedEvent = null;
			}
			FsmState state2 = FsmUtil.GetState(fsm, "Show Prompt");
			FsmUtil.RemoveAction(state2, 0);
			FsmUtil.AddAction(state2, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(1f),
				realTime = false
			});
			FsmUtil.AddLambdaMethod(state2, (Action<Action>)delegate(Action fin)
			{
				HeroController.instance.RelinquishControl();
				RandoPlugin.GM.playerData.disableInventory = false;
				AwardCollectable();
				HeroController.instance.RegainControl();
				fin();
			});
			FsmUtil.AddAction(state2, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmUtil.RemoveTransitionsTo(state2, "Singing End");
			FsmUtil.AddTransition(state2, "FINISHED", "Singing End");
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	public class ConductorMelodyLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public ConductorMelodyLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "melody_Conductor";
		}

		public override void SetItem(string item)
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00d5: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			FsmUtil.ReplaceAction(FsmUtil.GetState(fsm, "Has Item?"), 3, (FsmStateAction)new SetBoolValue
			{
				boolVariable = FsmUtil.GetBoolVariable(fsm, "Is Melody Quest Active"),
				boolValue = FsmBool.op_Implicit(false)
			});
			FsmUtil.GetAction<CheckQuestStateV2>(FsmUtil.GetState(fsm, "Quest Active?"), 0).NotTrackedEvent = FsmUtil.GetState(fsm, "Quest Active?").GetTransitionEvent(1);
			FsmTemplateControl fsmTemplateControl = FsmUtil.GetAction<RunFSM>(FsmUtil.GetState(fsm, "Run Melody Play Prompted"), 5).fsmTemplateControl;
			FsmState state = fsmTemplateControl.RunFsm.GetState("Give Item");
			FsmUtil.RemoveAction(state, 0);
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmUtil.AddLambdaMethod(state, (Action<Action>)delegate(Action fin)
			{
				AwardCollectable();
				fin();
			});
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmState state2 = fsmTemplateControl.RunFsm.GetState("UI Msg");
			FsmUtil.RemoveAction(state2, 4);
			FsmUtil.RemoveAction(state2, 3);
			FsmUtil.RemoveAction(state2, 1);
			FsmUtil.RemoveAction(state2, 0);
			FsmUtil.RemoveTransitionsTo(state2, "Stop Needolin");
			FsmUtil.AddTransition(state2, "FINISHED", "Stop Needolin");
			FsmState state3 = fsmTemplateControl.RunFsm.GetState("Stop Needolin");
			FsmUtil.RemoveTransitionsTo(state3, "Give Item");
			FsmUtil.AddTransition(state3, "FINISHED", "Give Item");
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	public class VaultMelodyLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public VaultMelodyLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "melody_Vault";
		}

		public override void SetItem(string item)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0055: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			FsmTemplateControl fsmTemplateControl = FsmUtil.GetAction<RunFSM>(FsmUtil.GetState(fsm, "Needolin"), 4).fsmTemplateControl;
			FsmState state = fsmTemplateControl.RunFsm.GetState("Give Item");
			FsmUtil.RemoveAction(state, 0);
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmUtil.AddLambdaMethod(state, (Action<Action>)delegate(Action fin)
			{
				AwardCollectable();
				fin();
			});
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmState state2 = fsmTemplateControl.RunFsm.GetState("UI Msg");
			FsmUtil.RemoveAction(state2, 4);
			FsmUtil.RemoveAction(state2, 3);
			FsmUtil.RemoveAction(state2, 1);
			FsmUtil.RemoveAction(state2, 0);
			FsmUtil.RemoveTransitionsTo(state2, "Stop Needolin");
			FsmUtil.AddTransition(state2, "FINISHED", "Stop Needolin");
			FsmState state3 = fsmTemplateControl.RunFsm.GetState("Stop Needolin");
			FsmUtil.RemoveTransitionsTo(state3, "Give Item");
			FsmUtil.AddTransition(state3, "FINISHED", "Give Item");
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	public enum MossberryLocationType
	{
		Vine,
		Aspid
	}
	public class MossberryLocation : ItemLocation
	{
		private MossberryLocationType locType;

		private PlayMakerFSM fsm;

		private HealthManager aspid;

		public MossberryLocation(PlayMakerFSM fsm)
		{
			locType = MossberryLocationType.Vine;
			this.fsm = fsm;
		}

		public MossberryLocation(HealthManager aspid, PlayMakerFSM fsm)
		{
			locType = MossberryLocationType.Aspid;
			this.aspid = aspid;
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "Mossberry";
		}

		public override void SetItem(string item)
		{
			Object.Destroy((Object)(object)((Component)fsm).GetComponent<PersistentBoolItem>());
			if (locType == MossberryLocationType.Vine)
			{
				if (SaveData.Instance.CollectedChecks.Contains(GetLocationID()))
				{
					((Component)fsm).gameObject.SetActive(false);
				}
				FsmUtil.InsertLambdaMethod(fsm.fsm.GetState("Init"), 4, (Action<Action>)delegate(Action fin)
				{
					FsmState state2 = FsmUtil.GetGameObjectVariable(fsm.fsm, "Fruit").Value.GetComponent<PlayMakerFSM>().fsm.GetState("Collect");
					FsmUtil.RemoveAction(state2, 2);
					FsmUtil.InsertLambdaMethod(state2, 2, (Action<Action>)delegate(Action fin)
					{
						AwardCollectable();
						fin();
					});
					fin();
				});
			}
			else if (locType == MossberryLocationType.Aspid)
			{
				RandoPlugin.Log.LogInfo((object)aspid);
				RandoPlugin.Log.LogInfo((object)fsm);
				FsmState state = fsm.fsm.GetState("Collect");
				FsmUtil.RemoveAction(state, 2);
				FsmUtil.InsertLambdaMethod(state, 2, (Action<Action>)delegate(Action fin)
				{
					AwardCollectable();
					fin();
				});
			}
		}

		public override GameObject GetObj()
		{
			if (locType == MossberryLocationType.Vine)
			{
				return ((Component)fsm).gameObject;
			}
			if (locType == MossberryLocationType.Aspid)
			{
				return ((Component)aspid).gameObject;
			}
			return ((Component)fsm).gameObject;
		}

		public static void InstallHooks()
		{
			PlayerDataVariableEvents.OnGetBool += delegate(PlayerData pd, string name, bool current)
			{
				if (RandoPlugin.instance.GameMode.Enabled)
				{
					switch (name)
					{
					case "mosstownAspidBerryCollected":
						return SaveData.Instance.CollectedChecks.Contains("Bone_05b|Mossberry");
					case "bonegraveAspidBerryCollected":
						return SaveData.Instance.CollectedChecks.Contains("Bonegrave|Mossberry");
					case "bonetownAspidBerryCollected":
						return SaveData.Instance.CollectedChecks.Contains("Bonetown|Mossberry");
					}
				}
				return current;
			};
		}
	}
	public class NeedolinLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public NeedolinLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "ability_Needolin";
		}

		public override void SetItem(string item)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			FsmUtil.RemoveAction(FsmUtil.GetState(fsm, "Final Bind Burst"), 3);
			FsmState state = FsmUtil.GetState(fsm, "Get Needolin");
			FsmUtil.RemoveAction(state, 1);
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false
			});
			FsmUtil.AddLambdaMethod(state, (Action<Action>)delegate(Action fin)
			{
				AwardCollectable();
				PlayerData.instance.spinnerDefeated = true;
				HeroController.instance.SetSilkRegenBlocked(true);
				PlayerData.instance.disableInventory = false;
				fin();
			});
			FsmUtil.AddAction(state, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(1f),
				realTime = false
			});
			FsmUtil.AddAction(state, (FsmStateAction)new QueueMemoryFullHeal());
			FsmUtil.AddAction(state, (FsmStateAction)new ToolsCutsceneControl
			{
				SetInCutscene = FsmBool.op_Implicit(false)
			});
			BeginSceneTransition action = FsmUtil.GetAction<BeginSceneTransition>(FsmUtil.GetState(fsm, "To Memory Scene"), 2);
			action.sceneName = FsmString.op_Implicit("Belltown_Shrine");
			action.entryGateName = FsmString.op_Implicit("door_wakeOnGround");
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	public class PollipBulbLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public PollipBulbLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			return "Shell Flower";
		}

		public override void SetItem(string item)
		{
			Object.Destroy((Object)(object)((Component)((Component)fsm).transform.parent).GetComponent<PersistentBoolItem>());
			if (IsChecked())
			{
				((Component)((Component)fsm).transform.parent).gameObject.SetActive(false);
			}
			FsmState state = fsm.fsm.GetState("Collect");
			FsmUtil.RemoveAction(state, 6);
			FsmUtil.InsertLambdaMethod(state, 6, (Action<Action>)delegate(Action fin)
			{
				AwardCollectable();
				fin();
			});
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
	public class ShrineWeaverAbilityLocation : ItemLocation
	{
		private PlayMakerFSM fsm;

		public ShrineWeaverAbilityLocation(PlayMakerFSM fsm)
		{
			this.fsm = fsm;
		}

		public override string GetItem()
		{
			//IL_0017: 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)
			WeaverSpireAbility val = (WeaverSpireAbility)(object)fsm.FsmVariables.EnumVariables[0].Value;
			return "ability_" + ((object)(WeaverSpireAbility)(ref val)).ToString();
		}

		public override void SetItem(string item)
		{
			base.SetItem(item);
			Object.Destroy((Object)(object)((Component)fsm).GetComponent<PlayMakerNPC>());
			Object.Destroy((Object)(object)fsm);
		}

		public override GameObject GetObj()
		{
			return ((Component)fsm).gameObject;
		}
	}
}
namespace Silksong.Rando.Locations.Hooks
{
	[HarmonyPatch(typeof(CollectableItemPickup), "Start")]
	internal class CollectableItemPickup_Start_Patch
	{
		public static void Prefix(CollectableItemPickup __instance)
		{
			if (!(__instance.item is RandoItem) && !RandoPlugin.instance.PickupsToIgnore.Contains(__instance) && ((Object)__instance.item).name != "Trobbio Quill Red" && ((Object)__instance.item).name != "Shiny Bell Goomba")
			{
				new CollectableItemPickupLocation(__instance).AddToCurrentScene();
			}
		}
	}
	[HarmonyPatch(typeof(GeoRock), "Start")]
	internal class GeoRock_Start_Patch
	{
		public static void Prefix(GeoRock __instance)
		{
		}
	}
	[HarmonyPatch(typeof(HealthManager), "Start")]
	internal class HealthManager_Start_Patch
	{
		public static void Prefix(HealthManager __instance)
		{
			if (!((Object)((Component)__instance).gameObject).name.StartsWith("Aspid Collector"))
			{
				return;
			}
			for (int i = 0; i < ((Component)__instance).transform.childCount; i++)
			{
				if (((Object)((Component)((Component)__instance).transform.GetChild(i)).gameObject).name == "Mossberry Pickup")
				{
					new MossberryLocation(__instance, ((Component)((Component)__instance).transform.GetChild(i)).GetComponent<PlayMakerFSM>()).AddToCurrentScene();
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayMakerFSM), "Start")]
	internal class PlayMakerFSM_Start_Patch
	{
		public static void Prefix(PlayMakerFSM __instance)
		{
			if (((Object)__instance).name == "Shrine Weaver Ability")
			{
				new ShrineWeaverAbilityLocation(__instance).AddToCurrentScene();
			}
			if (((Object)__instance).name == "Big Flower")
			{
				new PollipBulbLocation(((Component)((Component)__instance).transform.GetChild(1)).GetComponent<PlayMakerFSM>()).AddToCurrentScene();
			}
			if (((Object)__instance).name == "moss_berry_fruit")
			{
				new MossberryLocation(__instance).AddToCurrentScene();
			}
			if (((Object)__instance).name == "Spinner Boss" && __instance.FsmName == "Control")
			{
				new NeedolinLocation(__instance).AddToCurrentScene();
			}
			if (((Object)__instance).name == "Seamstress" && __instance.FsmName == "Dialogue")
			{
				new BrollyLocation(__instance).AddToCurrentScene();
			}
			if (((Object)__instance).name == "Librarian" && __instance.FsmName == "Dialogue" && FsmUtil.GetState(__instance, "Open Relic Board") != null)
			{
				new VaultMelodyLocation(__instance).AddToCurrentScene();
			}
			if (((Object)__instance).name == "puzzle cylinders" && __instance.FsmName == "Cylinder States")
			{
				new ArchitectMelodyLocation(__instance).AddToCurrentScene();
			}
			if (((Object)__instance).name == "Last Conductor NPC" && __instance.FsmName == "Dialogue")
			{
				new ConductorMelodyLocation(__instance).AddToCurrentScene();
			}
			if (((Object)__instance).name == "DJ Get Sequence")
			{
				new DJLocation(__instance).AddToCurrentScene();
			}
		}
	}
}
namespace Silksong.Rando.Hooks
{
	[HarmonyPatch]
	public class CollectableItemManagerHooks
	{
		public static List<string> cachedItems = new List<string>();

		[HarmonyPatch(typeof(CollectableItemManager), "Awake")]
		[HarmonyPrefix]
		public static void BeginSceneTransition(CollectableItemManager __instance)
		{
			Dictionary<string, ItemLocationData> dictionary = JsonConvert.DeserializeObject<Dictionary<string, ItemLocationData>>(ModResources.LoadData("locations"));
			if (cachedItems.Count == dictionary.Count)
			{
				return;
			}
			cachedItems.Clear();
			foreach (KeyValuePair<string, ItemLocationData> item in dictionary)
			{
				cachedItems.Add(((Object)RandoPlugin.GetCollectableItem(item.Value.item, item.Key)).name);
			}
		}

		[HarmonyPatch(typeof(CollectableItemManager), "IsItemInMasterList", new Type[] { typeof(string) })]
		[HarmonyPrefix]
		public static bool IsItemInMasterList(CollectableItemManager __instance, ref bool __result, string itemName)
		{
			if (cachedItems.Contains(itemName))
			{
				__result = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	public class GameManagerHooks
	{
		[HarmonyPatch(typeof(GameManager), "BeginSceneTransition", new Type[] { typeof(SceneLoadInfo) })]
		[HarmonyPostfix]
		public static void BeginSceneTransition(GameManager __instance, SceneLoadInfo info)
		{
			if (RandoPlugin.instance.GameMode.Enabled && info.SceneName == "Opening_Sequence" && SaveData.Instance.RandoSeed == -1)
			{
				int num = Random.Range(0, int.MaxValue);
				RandoPlugin.Log.LogInfo((object)$"Starting rando with seed {num}");
				SaveData.Instance.RandoSeed = num;
				SaveData.Instance.ItemReplacements = RandoPlugin.instance.logic.GenerateSeed(num);
			}
		}

		[HarmonyPatch(typeof(GameManager), "ClearSaveFile", new Type[]
		{
			typeof(int),
			typeof(Action<bool>)
		})]
		[HarmonyPostfix]
		public static void ClearSaveFile(GameManager __instance, int saveSlot, Action<bool> callback)
		{
			if (RandoPlugin.instance.GameMode.Enabled)
			{
				SaveData.Clear();
			}
		}

		[HarmonyPatch(typeof(GameManager), "Start")]
		[HarmonyPostfix]
		public static void Start(GameManager __instance)
		{
			RandoPlugin.instance.LoadFakeCollectables();
		}
	}
}