using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Architect.Api;
using Architect.Behaviour.Abilities;
using Architect.Behaviour.Custom;
using Architect.Behaviour.Fixers;
using Architect.Behaviour.Utility;
using Architect.Config;
using Architect.Config.Types;
using Architect.Content;
using Architect.Content.Custom;
using Architect.Content.Preloads;
using Architect.Editor;
using Architect.Events;
using Architect.Events.Blocks;
using Architect.Events.Blocks.Config;
using Architect.Events.Blocks.Config.Types;
using Architect.Events.Blocks.Events;
using Architect.Events.Blocks.Functions;
using Architect.Events.Blocks.Objects;
using Architect.Events.Blocks.Operators;
using Architect.Events.Blocks.Outputs;
using Architect.Events.Vars;
using Architect.Multiplayer;
using Architect.Multiplayer.Ssmp;
using Architect.Multiplayer.Ssmp.Data;
using Architect.Objects;
using Architect.Objects.Categories;
using Architect.Objects.Groups;
using Architect.Objects.Placeable;
using Architect.Objects.Tools;
using Architect.Placements;
using Architect.Prefabs;
using Architect.Sharer;
using Architect.Sharer.Info;
using Architect.Sharer.States;
using Architect.Storage;
using Architect.Utils;
using Architect.Workshop;
using Architect.Workshop.Config;
using Architect.Workshop.Items;
using Architect.Workshop.Types;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalEnums;
using GlobalSettings;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using InControl;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using Newtonsoft.Json;
using Patchwork.Handlers;
using PolyAndCode.UI;
using PrepatcherPlugin;
using QuickWarp;
using SSMP.Api.Client;
using SSMP.Api.Client.Networking;
using SSMP.Api.Server;
using SSMP.Api.Server.Networking;
using SSMP.Math;
using SSMP.Networking.Packet;
using Silksong.AssetHelper.ManagedAssets;
using Silksong.AssetHelper.Plugin;
using Silksong.DataManager;
using Silksong.ModMenu;
using Silksong.ModMenu.Elements;
using Silksong.ModMenu.Models;
using Silksong.ModMenu.Screens;
using TMProOld;
using TeamCherry.Localization;
using TeamCherry.SharedUtils;
using TeamCherry.Splines;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.Audio;
using UnityEngine.Bindings;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;
using UnityStandardAssets.ImageEffects;
using tk2dRuntime.TileMap;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Architect")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("3.28.0.0")]
[assembly: AssemblyInformationalVersion("3.28.0+e580782e34ca3b99fa47182fbf9ff38785592697")]
[assembly: AssemblyProduct("Architect")]
[assembly: AssemblyTitle("Architect")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.28.0.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;
		}
	}
}
namespace MonoDetour.HookGen
{
	internal static class DefaultMonoDetourManager
	{
		internal static MonoDetourManager Instance { get; } = New();


		internal static MonoDetourManager New()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new MonoDetourManager(typeof(DefaultMonoDetourManager).Assembly.GetName().Name);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal class MonoDetourTargetsAttribute : Attribute, IMonoDetourTargets
	{
		public Type? TargetType { get; }

		public bool IncludeNestedTypes { get; set; }

		public bool DistinguishOverloadsByName { get; set; }

		public string[]? Members { get; set; }

		public string[]? MemberNamePrefixes { get; set; }

		public string[]? MemberNameSuffixes { get; set; }

		public bool GenerateControlFlowVariants { get; set; }

		public MonoDetourTargetsAttribute(Type? targetType = null)
		{
			TargetType = targetType;
			IncludeNestedTypes = true;
			base..ctor();
		}
	}
}
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 Architect
{
	public class ArchitectData
	{
		public Dictionary<string, string> StringVariables = new Dictionary<string, string>();

		public Dictionary<string, float> FloatVariables = new Dictionary<string, float>();

		public Dictionary<string, bool> BoolVariables = new Dictionary<string, bool>();

		public string CustomNeedle = string.Empty;

		public static ArchitectData Instance => ArchitectPlugin.Instance.SaveData ?? (ArchitectPlugin.Instance.SaveData = new ArchitectData());
	}
	public class GlobalArchitectData
	{
		public Dictionary<string, KeyCode> Keybinds = new Dictionary<string, KeyCode>();

		public string CurrentMap = "";

		public string CurrentMapId = "";

		public Dictionary<string, (List<string>, int)> CherryScores = new Dictionary<string, (List<string>, int)>();

		public Dictionary<string, (List<string>, int)> GoldCherryScores = new Dictionary<string, (List<string>, int)>();

		public Dictionary<int, (string, bool)> CustomSaveArt = new Dictionary<int, (string, bool)>();

		public List<string> SavedMapNames = new List<string>();

		public Dictionary<string, string> StringVariables = new Dictionary<string, string>();

		public Dictionary<string, float> FloatVariables = new Dictionary<string, float>();

		public Dictionary<string, bool> BoolVariables = new Dictionary<string, bool>();

		public static GlobalArchitectData Instance => ArchitectPlugin.Instance.GlobalData ?? (ArchitectPlugin.Instance.GlobalData = new GlobalArchitectData());

		public string MapLabel => Utility.IsNullOrWhiteSpace(CurrentMap) ? "Map Keybinds" : CurrentMap;
	}
	[BepInPlugin("com.cometcake575.architect", "Architect", "3.28.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ArchitectPlugin : BaseUnityPlugin, ISaveDataMod<ArchitectData>, IRawSaveDataMod, IGlobalDataMod<GlobalArchitectData>, IRawGlobalDataMod
	{
		internal static ArchitectPlugin Instance;

		internal static ManualLogSource Logger;

		public static readonly Sprite BlankSprite = ResourceUtils.LoadSpriteResource("blank", (FilterMode)1, default(Vector4), 300f);

		public ArchitectData SaveData { get; set; }

		public GlobalArchitectData GlobalData { get; set; }

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Architect has loaded!");
			SceneUtils.Init();
			PrefabManager.Init();
			HookUtils.Init();
			TitleUtils.Init();
			StorageManager.Init();
			Settings.Init(((BaseUnityPlugin)this).Config);
			MiscFixers.Init();
			EnemyFixers.Init();
			HazardFixers.Init();
			InteractableFixers.Init();
			Categories.Init();
			ActionManager.Init();
			CoopManager.Init();
			WorkshopManager.Init();
			ScriptManager.Init();
			EditManager.Init();
			CursorManager.Init();
			VanillaObjects.Init();
			SplineObjects.Init();
			LegacyObjects.Init();
			UtilityObjects.Init();
			AbilityObjects.Init();
			MiscObjects.Init();
			CameraObjects.Init();
			ParticleObjects.Init();
			RespawnMarkerManager.Init();
			PlacementManager.Init();
			BroadcasterHooks.Init();
			SharerManager.Init();
			PreloadManager.Init();
			EditorUI.Setup();
			Architect.Objects.Groups.ConfigGroup.Init();
			StorageManager.MakeBackup(DateTime.Now.ToString("yy-MM-dd-HH-mm-ss"));
			ProjectManager.Init();
			typeof(GameManager).Hook("ResetSemiPersistentItems", (Action<Action<GameManager>, GameManager>)delegate(Action<GameManager> orig, GameManager self)
			{
				BoolVarBlock.SemiVars.Clear();
				NumVarBlock.SemiVars.Clear();
				StringVarBlock.SemiVars.Clear();
				orig(self);
			});
			FindMaps();
		}

		private static void FindMaps()
		{
			string[] directories = Directory.GetDirectories(Paths.PluginPath, "Architect", SearchOption.AllDirectories);
			foreach (string text in directories)
			{
				if (text == Path.Combine(Paths.PluginPath, "Architect"))
				{
					continue;
				}
				string path = Path.Combine(text, "Scenes");
				if (Directory.Exists(path))
				{
					string[] files = Directory.GetFiles(path);
					foreach (string text2 in files)
					{
						if (text2.EndsWith(".architect.json"))
						{
							string sceneName = Path.GetFileNameWithoutExtension(text2).Replace(".architect", "");
							MapLoader.LoadStandaloneMap(sceneName, text2);
						}
					}
				}
				string path2 = Path.Combine(text, "Prefabs");
				if (Directory.Exists(path2))
				{
					string[] files2 = Directory.GetFiles(path2);
					foreach (string text3 in files2)
					{
						if (text3.EndsWith(".architect.json"))
						{
							string prefabName = Path.GetFileNameWithoutExtension(text3).Replace(".architect", "");
							MapLoader.LoadStandalonePrefab(prefabName, text3);
						}
					}
				}
				string text4 = Path.Combine(text, "Assets");
				if (Directory.Exists(text4))
				{
					CustomAssetManager.AssetPaths.Add(text4);
				}
				StorageManager.LoadPrefabs(text);
				string path3 = Path.Combine(text, "workshop.json");
				if (File.Exists(path3))
				{
					string text5 = File.ReadAllText(path3);
					WorkshopManager.LoadExtWorkshop(JsonConvert.DeserializeObject<WorkshopData>(text5));
				}
				StorageManager.Directories.Add(text);
			}
		}

		private void Start()
		{
			EditorUI.SetupCategories();
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)HeroController.instance))
			{
				EditManager.Update();
				HazardFixers.UpdateLanterns();
			}
			CursorManager.Update();
			SharerManager.Update();
			AbilityObjects.Update();
		}
	}
}
namespace Architect.Workshop
{
	public static class ConfigurationManager
	{
		public static readonly Dictionary<string, Architect.Workshop.Types.ConfigType> ConfigTypes = new Dictionary<string, Architect.Workshop.Types.ConfigType>();

		public static Architect.Workshop.Types.ConfigType RegisterConfigType(Architect.Workshop.Types.ConfigType type)
		{
			ConfigTypes[type.Id] = type;
			return type;
		}

		public static Architect.Workshop.Types.ConfigValue DeserializeConfigValue(string configType, string serializedValue)
		{
			return ConfigTypes[configType].Deserialize(serializedValue);
		}
	}
	[JsonConverter(typeof(WorkshopDataConverter))]
	public class WorkshopData
	{
		public class WorkshopDataConverter : JsonConverter<WorkshopData>
		{
			public override void WriteJson(JsonWriter writer, WorkshopData value, JsonSerializer serializer)
			{
				writer.WriteStartObject();
				writer.WritePropertyName("items");
				writer.WriteStartArray();
				foreach (WorkshopItem item in value.Items)
				{
					writer.WriteStartObject();
					writer.WritePropertyName("type");
					writer.WriteValue(item.Type);
					writer.WritePropertyName("name");
					writer.WriteValue(item.Id);
					writer.WritePropertyName("config");
					serializer.Serialize(writer, (object)item.CurrentConfig.Values.ToDictionary((Architect.Workshop.Types.ConfigValue c) => c.GetTypeId(), (Architect.Workshop.Types.ConfigValue c) => c.SerializeValue()));
					writer.WriteEndObject();
				}
				writer.WriteEndArray();
				writer.WriteEndObject();
			}

			public override WorkshopData ReadJson(JsonReader reader, Type objectType, WorkshopData existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Invalid comparison between Unknown and I4
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Invalid comparison between Unknown and I4
				WorkshopData workshopData = new WorkshopData();
				reader.Read();
				reader.Read();
				reader.Read();
				while ((int)reader.TokenType == 1)
				{
					string key = "";
					string arg = "";
					Dictionary<string, Architect.Workshop.Types.ConfigValue> currentConfig = new Dictionary<string, Architect.Workshop.Types.ConfigValue>();
					reader.Read();
					while ((int)reader.TokenType == 4)
					{
						switch (reader.Value as string)
						{
						case "type":
							key = reader.ReadAsString();
							break;
						case "name":
							arg = reader.ReadAsString();
							break;
						case "config":
							reader.Read();
							currentConfig = DeserializeConfig(serializer.Deserialize<Dictionary<string, string>>(reader));
							break;
						}
						reader.Read();
					}
					WorkshopItem workshopItem = WorkshopManager.WorkshopItems[key].Item2(arg);
					workshopItem.CurrentConfig = currentConfig;
					workshopData.Items.Add(workshopItem);
					reader.Read();
				}
				reader.Read();
				return workshopData;
			}

			private static Dictionary<string, Architect.Workshop.Types.ConfigValue> DeserializeConfig(Dictionary<string, string> data)
			{
				Dictionary<string, Architect.Workshop.Types.ConfigValue> dictionary = new Dictionary<string, Architect.Workshop.Types.ConfigValue>();
				foreach (KeyValuePair<string, string> datum in data)
				{
					dictionary[datum.Key] = ConfigurationManager.DeserializeConfigValue(datum.Key, datum.Value);
				}
				return dictionary;
			}
		}

		public readonly List<WorkshopItem> Items = new List<WorkshopItem>();
	}
	public static class WorkshopManager
	{
		public static WorkshopData WorkshopData;

		public static readonly Dictionary<string, WorkshopItem> CustomItems = new Dictionary<string, WorkshopItem>();

		public static readonly Dictionary<string, WorkshopItem> CustomEntries = new Dictionary<string, WorkshopItem>();

		public static readonly Dictionary<string, WorkshopItem> CustomCrests = new Dictionary<string, WorkshopItem>();

		public static readonly Dictionary<string, WorkshopItem> CustomQuests = new Dictionary<string, WorkshopItem>();

		public static readonly Dictionary<string, WorkshopItem> CustomTools = new Dictionary<string, WorkshopItem>();

		public static readonly Dictionary<string, (Vector2, Func<string, WorkshopItem>)> WorkshopItems = new Dictionary<string, (Vector2, Func<string, WorkshopItem>)>();

		private static readonly List<WorkshopData> ExtWorkshops = new List<WorkshopData>();

		public static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			Register<CustomItem>("Item", new Vector2(-300f, -150f), new List<Architect.Workshop.Types.ConfigType>[4]
			{
				Architect.Workshop.Config.ConfigGroup.CustomItem,
				Architect.Workshop.Config.ConfigGroup.SpriteItem,
				Architect.Workshop.Config.ConfigGroup.UsableItem,
				Architect.Workshop.Config.ConfigGroup.CourierItem
			});
			Register<CustomTool>("Tool", new Vector2(-300f, -187.5f), new List<Architect.Workshop.Types.ConfigType>[4]
			{
				Architect.Workshop.Config.ConfigGroup.CustomTool,
				Architect.Workshop.Config.ConfigGroup.SpriteItem,
				Architect.Workshop.Config.ConfigGroup.UseToolSprites,
				Architect.Workshop.Config.ConfigGroup.RedTools
			});
			Register<CustomJournalEntry>("Journal Entry", new Vector2(-100f, -187.5f), new List<Architect.Workshop.Types.ConfigType>[3]
			{
				Architect.Workshop.Config.ConfigGroup.JournalEntry,
				Architect.Workshop.Config.ConfigGroup.SpriteItem,
				Architect.Workshop.Config.ConfigGroup.JournalEntrySprites
			});
			Register<CustomQuest>("Quest", new Vector2(-100f, -150f), new List<Architect.Workshop.Types.ConfigType>[4]
			{
				Architect.Workshop.Config.ConfigGroup.Quest,
				Architect.Workshop.Config.ConfigGroup.QuestSprites,
				new List<Architect.Workshop.Types.ConfigType>(),
				Architect.Workshop.Config.ConfigGroup.QuestItem
			});
			Register<SceneGroup>("Scene Group", new Vector2(-300f, -225f), new List<Architect.Workshop.Types.ConfigType>[6]
			{
				Architect.Workshop.Config.ConfigGroup.SceneGroup,
				Architect.Workshop.Config.ConfigGroup.SceneGroupIcon,
				Architect.Workshop.Config.ConfigGroup.SceneGroupMap,
				Architect.Workshop.Config.ConfigGroup.SceneGroupMapPos,
				Architect.Workshop.Config.ConfigGroup.SceneGroupMapDirIn,
				Architect.Workshop.Config.ConfigGroup.SceneGroupMapDirOut
			});
			Register<CustomScene>("Scene", new Vector2(-100f, -225f), new List<Architect.Workshop.Types.ConfigType>[3]
			{
				Architect.Workshop.Config.ConfigGroup.Scene,
				Architect.Workshop.Config.ConfigGroup.SceneMap,
				Architect.Workshop.Config.ConfigGroup.SceneMapColour
			});
			Register<CustomMateriumEntry>("Material", new Vector2(-300f, -262.5f), new List<Architect.Workshop.Types.ConfigType>[2]
			{
				Architect.Workshop.Config.ConfigGroup.MateriumEntry,
				Architect.Workshop.Config.ConfigGroup.SpriteItem
			});
			Register<CustomMapIcon>("Map Icon", new Vector2(-100f, -262.5f), new List<Architect.Workshop.Types.ConfigType>[3]
			{
				Architect.Workshop.Config.ConfigGroup.MapIcon,
				Architect.Workshop.Config.ConfigGroup.SpriteItem,
				Architect.Workshop.Config.ConfigGroup.MapIconLabel
			});
			CustomKeybind.Init();
			Register<CustomKeybind>("Keybind", new Vector2(-300f, -300f), new List<Architect.Workshop.Types.ConfigType>[1] { Architect.Workshop.Config.ConfigGroup.Keybind });
			Register<CustomCue>("Audio Cue", new Vector2(-100f, -300f), new List<Architect.Workshop.Types.ConfigType>[1] { Architect.Workshop.Config.ConfigGroup.Cue });
			CustomNeedle.Init();
			Register<CustomNeedle>("Needle", new Vector2(-300f, -337.5f), new List<Architect.Workshop.Types.ConfigType>[2]
			{
				Architect.Workshop.Config.ConfigGroup.Needle,
				Architect.Workshop.Config.ConfigGroup.SpriteItem
			});
			Register<CustomAchievement>("Achievement", new Vector2(-100f, -337.5f), new List<Architect.Workshop.Types.ConfigType>[1] { Architect.Workshop.Config.ConfigGroup.Achievement });
			CustomCrest.Init();
			Register<CustomCrest>("Crest", new Vector2(-300f, -375f), new List<Architect.Workshop.Types.ConfigType>[3]
			{
				Architect.Workshop.Config.ConfigGroup.Crest,
				Architect.Workshop.Config.ConfigGroup.SpriteItem,
				Architect.Workshop.Config.ConfigGroup.CrestSprites
			});
			Register<CustomCrest.CrestSlot>("Crest Slot", new Vector2(-100f, -375f), new List<Architect.Workshop.Types.ConfigType>[1] { Architect.Workshop.Config.ConfigGroup.CrestSlot });
			SceneGroup.Init();
			typeof(CollectableItemManager).Hook("InternalGetCollectedItems", (Func<Func<CollectableItemManager, Func<CollectableItem, bool>, List<CollectableItem>>, CollectableItemManager, Func<CollectableItem, bool>, List<CollectableItem>>)delegate(Func<CollectableItemManager, Func<CollectableItem, bool>, List<CollectableItem>> orig, CollectableItemManager self, Func<CollectableItem, bool> predicate)
			{
				if (Application.isPlaying)
				{
					RefreshItems();
					CollectableItemsData collectables = PlayerData.instance.Collectables;
					foreach (string item in from item in ((SerializableNamedList<Data, NamedData>)(object)collectables).GetValidNames((Func<Data, bool>)null)
						where !self.IsItemInMasterList(item)
						select item)
					{
						((SerializableNamedList<Data, NamedData>)(object)collectables).RuntimeData.Remove(item);
						CollectableItemManager.IncrementVersion();
					}
				}
				return orig(self, predicate);
			});
			typeof(HeroController).Hook("ThrowTool", (Action<Action<HeroController, bool>, HeroController, bool>)delegate(Action<HeroController, bool> orig, HeroController self, bool isAutoThrow)
			{
				//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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected I4, but got Unknown
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)self.willThrowTool))
				{
					if (CustomTool.List.Contains(self.willThrowTool.name))
					{
						ToolItemType type = self.willThrowTool.type;
						ToolItemType val = type;
						switch ((int)val)
						{
						case 3:
							HeroController.instance.TakeSilk(PlayerData.instance.SilkSkillCost);
							break;
						case 0:
						{
							Data savedData = self.willThrowTool.SavedData;
							savedData.AmountLeft--;
							self.willThrowTool.SavedData = savedData;
							ToolItemManager.ReportAllBoundAttackToolsUpdated();
							break;
						}
						}
					}
					ToolBlock.DoBroadcast(self.willThrowTool.name);
				}
				orig(self, isAutoThrow);
			});
			static void RefreshItems()
			{
				KeyValuePair<string, WorkshopItem>[] array = CustomItems.ToArray();
				string key;
				WorkshopItem value;
				foreach (KeyValuePair<string, WorkshopItem> keyValuePair in array)
				{
					keyValuePair.Deconstruct(out key, out value);
					string key2 = key;
					WorkshopItem workshopItem = value;
					if (!((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).dictionary.ContainsKey(key2))
					{
						workshopItem.Unregister();
						workshopItem.Register();
					}
				}
				KeyValuePair<string, WorkshopItem>[] array2 = CustomEntries.ToArray();
				foreach (KeyValuePair<string, WorkshopItem> keyValuePair in array2)
				{
					keyValuePair.Deconstruct(out key, out value);
					string key3 = key;
					WorkshopItem workshopItem2 = value;
					if (!((NamedScriptableObjectList<EnemyJournalRecord>)(object)EnemyJournalManager.Instance.recordList).dictionary.ContainsKey(key3))
					{
						workshopItem2.Unregister();
						workshopItem2.Register();
					}
				}
				KeyValuePair<string, WorkshopItem>[] array3 = CustomCrests.ToArray();
				foreach (KeyValuePair<string, WorkshopItem> keyValuePair in array3)
				{
					keyValuePair.Deconstruct(out key, out value);
					string key4 = key;
					WorkshopItem workshopItem3 = value;
					if (!((NamedScriptableObjectList<ToolCrest>)(object)ManagerSingleton<ToolItemManager>.Instance.crestList).dictionary.ContainsKey(key4))
					{
						workshopItem3.Unregister();
						workshopItem3.Register();
					}
				}
				KeyValuePair<string, WorkshopItem>[] array4 = CustomQuests.ToArray();
				foreach (KeyValuePair<string, WorkshopItem> keyValuePair in array4)
				{
					keyValuePair.Deconstruct(out key, out value);
					string key5 = key;
					WorkshopItem workshopItem4 = value;
					if (!((NamedScriptableObjectList<BasicQuestBase>)(object)QuestManager.Instance.masterList).dictionary.ContainsKey(key5))
					{
						workshopItem4.Unregister();
						workshopItem4.Register();
					}
				}
				KeyValuePair<string, WorkshopItem>[] array5 = CustomTools.ToArray();
				foreach (KeyValuePair<string, WorkshopItem> keyValuePair in array5)
				{
					keyValuePair.Deconstruct(out key, out value);
					string key6 = key;
					WorkshopItem workshopItem5 = value;
					if (!((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).dictionary.ContainsKey(key6))
					{
						workshopItem5.Unregister();
						workshopItem5.Register();
					}
				}
			}
		}

		public static void Setup()
		{
			CustomAchievement.Init();
			SceneUtils.InitQWHook();
			StorageManager.LoadWorkshopData();
			foreach (WorkshopItem item in from i in ExtWorkshops.SelectMany((WorkshopData data) => data.Items)
				orderby i.GetPriority()
				select i)
			{
				if (WorkshopData.Items.Any((WorkshopItem i) => i.Id == item.Id))
				{
					continue;
				}
				foreach (Architect.Workshop.Types.ConfigValue value in item.CurrentConfig.Values)
				{
					value.Setup(item);
				}
				item.Register();
			}
		}

		public static void LoadExtWorkshop(WorkshopData data)
		{
			ExtWorkshops.Add(data);
		}

		public static void LoadWorkshop(WorkshopData data)
		{
			if (data == null)
			{
				data = new WorkshopData();
			}
			if (WorkshopData != null)
			{
				foreach (WorkshopItem item in WorkshopData.Items)
				{
					item.Unregister();
				}
			}
			WorkshopData = data;
			foreach (WorkshopItem item2 in WorkshopData.Items.OrderBy((WorkshopItem i) => i.GetPriority()))
			{
				foreach (Architect.Workshop.Types.ConfigValue value in item2.CurrentConfig.Values)
				{
					value.Setup(item2);
				}
				item2.Register();
			}
			WorkshopUI.Refresh();
		}

		private static void Register<T>(string type, Vector2 pos, params List<Architect.Workshop.Types.ConfigType>[] config) where T : WorkshopItem, new()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			pos.y += 5f;
			WorkshopItems[type] = (pos, (string s) => new T
			{
				Id = s,
				Type = type,
				Config = config,
				CurrentConfig = new Dictionary<string, Architect.Workshop.Types.ConfigValue>()
			});
		}
	}
}
namespace Architect.Workshop.Types
{
	public class BoolConfigType<T> : ConfigType<T, BoolConfigValue<T>> where T : WorkshopItem
	{
		private bool? _defaultValue;

		public BoolConfigType(string name, string id, Action<T, BoolConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public BoolConfigType<T> WithDefaultValue(bool value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new BoolConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new BoolConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new BoolConfigValue<T>(this, Convert.ToBoolean(data, CultureInfo.InvariantCulture));
		}
	}
	public class BoolConfigValue<T> : ConfigValue<BoolConfigType<T>> where T : WorkshopItem
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private bool <value>P;

		public BoolConfigValue(BoolConfigType<T> type, bool value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public bool GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class BoolConfigElement : ConfigElement
	{
		private readonly Button _input;

		private bool _active = true;

		public BoolConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			BoolConfigElement boolConfigElement = this;
			UIUtils.Label txt;
			(_input, txt) = UIUtils.MakeTextButton("Config Input", "Default", parent, Vector2.op_Implicit(pos), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), hasOutline: true, new Vector2(120f, 25f));
			if (currentVal != null)
			{
				((Text)txt.textComponent).text = currentVal;
				_active = Convert.ToBoolean(currentVal, CultureInfo.InvariantCulture);
			}
			((UnityEvent)_input.onClick).AddListener((UnityAction)delegate
			{
				boolConfigElement._active = !boolConfigElement._active;
				((Text)txt.textComponent).text = boolConfigElement._active.ToString(CultureInfo.InvariantCulture);
				((Selectable)apply).interactable = true;
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _active.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class ChoiceConfigType<T> : ConfigType<T, ChoiceConfigValue<T>> where T : WorkshopItem
	{
		private int? _defaultValue;

		private string[] _options = Array.Empty<string>();

		public ChoiceConfigType(string name, string id, Action<T, ChoiceConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public ChoiceConfigType<T> WithOptions(params string[] options)
		{
			_options = options;
			return this;
		}

		public ChoiceConfigType<T> WithDefaultValue(int value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new ChoiceConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new ChoiceConfigElement(parent, apply, pos, currentVal, _options);
		}

		public override ConfigValue Deserialize(string data)
		{
			if (1 == 0)
			{
			}
			int num = ((!(data == "False")) ? ((data == "True") ? 1 : Convert.ToInt32(data, CultureInfo.InvariantCulture)) : 0);
			if (1 == 0)
			{
			}
			int value = num;
			return new ChoiceConfigValue<T>(this, value);
		}

		public string GetOption(int index)
		{
			return _options[(index < _options.Length) ? index : 0];
		}
	}
	public class ChoiceConfigValue<T> : ConfigValue<ChoiceConfigType<T>> where T : WorkshopItem
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private int <value>P;

		private readonly ChoiceConfigType<T> _type;

		public ChoiceConfigValue(ChoiceConfigType<T> type, int value)
		{
			<value>P = value;
			_type = type;
			base..ctor(type);
		}

		public int GetValue()
		{
			return <value>P;
		}

		public string GetStringValue()
		{
			return _type.GetOption(<value>P);
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class ChoiceConfigElement : ConfigElement
	{
		public class ChoiceButton : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			public ChoiceConfigElement Cce;

			public void OnPointerClick(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected I4, but got Unknown
				InputButton button = eventData.button;
				InputButton val = button;
				switch ((int)val)
				{
				default:
					return;
				case 0:
					Cce._active++;
					break;
				case 1:
					if (Cce._active != -1)
					{
						Cce._active--;
					}
					break;
				case 2:
					return;
				}
				if (Cce._active < 0)
				{
					Cce._active += Cce._options.Length;
				}
				Cce._active %= Cce._options.Length;
				((Text)Cce._txt.textComponent).text = Cce._options[Cce._active];
				((Selectable)Cce._apply).interactable = true;
			}
		}

		private readonly Button _input;

		private readonly string[] _options;

		private readonly Button _apply;

		private readonly UIUtils.Label _txt;

		private int _active = -1;

		public ChoiceConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal, string[] options)
		{
			//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: 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)
			(Button, UIUtils.Label) tuple = UIUtils.MakeTextButton("Config Input", "Default", parent, Vector2.op_Implicit(pos), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), hasOutline: true, new Vector2(120f, 25f));
			_input = tuple.Item1;
			_txt = tuple.Item2;
			_options = options;
			_apply = apply;
			ChoiceButton choiceButton = ((Component)_input).gameObject.AddComponent<ChoiceButton>();
			choiceButton.Cce = this;
			if (currentVal != null)
			{
				_active = Convert.ToInt32(currentVal, CultureInfo.InvariantCulture);
				((Text)_txt.textComponent).text = options[_active];
			}
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _active.ToString(CultureInfo.InvariantCulture);
		}
	}
	public abstract class ConfigType
	{
		public readonly string Name;

		public readonly string Id;

		public int Priority;

		protected ConfigType(string name, string id)
		{
			Name = name;
			Id = id;
			base..ctor();
		}

		public abstract ConfigValue Deserialize(string data);

		[CanBeNull]
		public abstract ConfigValue GetDefaultValue();

		public abstract ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal);

		internal abstract void RunAction(WorkshopItem item, ConfigValue value);
	}
	public abstract class ConfigType<TType, TValue> : ConfigType where TType : WorkshopItem where TValue : ConfigValue
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Action<TType, TValue> <action>P;

		protected ConfigType(string name, string id, Action<TType, TValue> action)
		{
			<action>P = action;
			base..ctor(name, id);
		}

		public ConfigType<TType, TValue> WithPriority(int priority)
		{
			Priority = priority;
			return this;
		}

		internal override void RunAction(WorkshopItem item, ConfigValue value)
		{
			<action>P(item as TType, value as TValue);
		}
	}
	public abstract class ConfigValue
	{
		public abstract string SerializeValue();

		public abstract string GetTypeId();

		public abstract string GetName();

		public abstract int GetPriority();

		public abstract void Setup(WorkshopItem item);
	}
	public abstract class ConfigValue<TType> : ConfigValue where TType : ConfigType
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private TType <type>P;

		protected ConfigValue(TType type)
		{
			<type>P = type;
			base..ctor();
		}

		public override string GetTypeId()
		{
			return <type>P.Id;
		}

		public override string GetName()
		{
			return <type>P.Name;
		}

		public override void Setup(WorkshopItem item)
		{
			<type>P.RunAction(item, this);
		}

		public override int GetPriority()
		{
			return <type>P.Priority;
		}
	}
	public abstract class ConfigElement
	{
		public abstract RectTransform GetElement();

		public abstract string GetValue();
	}
	public class FloatConfigType<T> : ConfigType<T, FloatConfigValue<T>> where T : WorkshopItem
	{
		private float? _defaultValue;

		public FloatConfigType(string name, string id, Action<T, FloatConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public FloatConfigType<T> WithDefaultValue(float value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new FloatConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new FloatConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			float value;
			try
			{
				value = Convert.ToSingle(data, CultureInfo.InvariantCulture);
			}
			catch (FormatException)
			{
				value = 9999999f;
			}
			return new FloatConfigValue<T>(this, value);
		}
	}
	public class FloatConfigValue<T> : ConfigValue<FloatConfigType<T>> where T : WorkshopItem
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private float <value>P;

		public FloatConfigValue(FloatConfigType<T> type, float value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public float GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class FloatConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public FloatConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), 120f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			_input.characterValidation = (CharacterValidation)2;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class IntConfigType<T> : ConfigType<T, IntConfigValue<T>> where T : WorkshopItem
	{
		private int? _defaultValue;

		public IntConfigType(string name, string id, Action<T, IntConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public IntConfigType<T> WithDefaultValue(int value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new IntConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new IntConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new IntConfigValue<T>(this, Convert.ToInt32(data, CultureInfo.InvariantCulture));
		}
	}
	public class IntConfigValue<T> : ConfigValue<IntConfigType<T>> where T : WorkshopItem
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private int <value>P;

		public IntConfigValue(IntConfigType<T> type, int value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public int GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class IntConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public IntConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), 120f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			_input.characterValidation = (CharacterValidation)1;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class NoteConfigType : ConfigType<WorkshopItem, NoteConfigValue>
	{
		public NoteConfigType(string name)
			: base(name, string.Empty, (Action<WorkshopItem, NoteConfigValue>)delegate
			{
			})
		{
		}

		public override ConfigValue GetDefaultValue()
		{
			return null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			return new NoteConfigElement(apply);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new NoteConfigValue(this, data);
		}

		public static implicit operator NoteConfigType(string s)
		{
			return new NoteConfigType(s);
		}
	}
	public class NoteConfigValue : ConfigValue<NoteConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <value>P;

		public NoteConfigValue(NoteConfigType type, string value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public override string SerializeValue()
		{
			return <value>P;
		}
	}
	public class NoteConfigElement : ConfigElement
	{
		private readonly Button _input;

		public NoteConfigElement(Button apply)
		{
			_input = apply;
			((Component)apply).gameObject.SetActive(false);
			((Component)((Component)apply).GetComponent<UIUtils.LabelledButton>().label).gameObject.SetActive(false);
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return "";
		}
	}
	public class StringConfigType<T> : ConfigType<T, StringConfigValue<T>> where T : WorkshopItem
	{
		[CanBeNull]
		private string _defaultValue;

		public StringConfigType(string name, string id, Action<T, StringConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public StringConfigType<T> WithDefaultValue(string value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return (_defaultValue == null) ? null : new StringConfigValue<T>(this, _defaultValue);
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new StringConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new StringConfigValue<T>(this, data);
		}
	}
	public class StringConfigValue<T> : ConfigValue<StringConfigType<T>> where T : WorkshopItem
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <value>P;

		public StringConfigValue(StringConfigType<T> type, string value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public string GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P;
		}
	}
	public class StringConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public StringConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), 220f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
}
namespace Architect.Workshop.Items
{
	public class CustomAchievement : SpriteItem
	{
		private static readonly Dictionary<string, CustomAchievement> Achievements = new Dictionary<string, CustomAchievement>();

		public string Name = string.Empty;

		public string Desc = string.Empty;

		public AchievementType AchievementType = (AchievementType)0;

		public string InsertBefore = string.Empty;

		private Achievement _achievement;

		public static void Init()
		{
			typeof(AchievementHandler).Hook("Start", (Action<Action<AchievementHandler>, AchievementHandler>)delegate(Action<AchievementHandler> orig, AchievementHandler self)
			{
				orig(self);
				CustomAchievement[] array = Achievements.Values.ToArray();
				foreach (CustomAchievement customAchievement in array)
				{
					customAchievement.Unregister();
					customAchievement.Register();
				}
			});
			typeof(UIManager).Hook("UIGoToAchievementsMenu", (Action<Action<UIManager>, UIManager>)delegate(Action<UIManager> orig, UIManager self)
			{
				orig(self);
				int num = 0;
				ICell[] componentsInChildren = ((Component)UIManager.instance.menuAchievementsList).GetComponentsInChildren<ICell>();
				foreach (ICell val in componentsInChildren)
				{
					UIManager.instance.menuAchievementsList.SetCell(val, num);
					num++;
				}
			});
			typeof(Language).Hook("Get", (Func<Func<string, string, string>, string, string, string>)delegate(Func<string, string, string> orig, string key, string sheetTitle)
			{
				if (sheetTitle == "Achievements")
				{
					foreach (CustomAchievement value in Achievements.Values)
					{
						if (key == value._achievement.TitleCell)
						{
							return value.Name;
						}
						if (key == value._achievement.DescriptionCell)
						{
							return value.Desc;
						}
					}
				}
				return orig(key, sheetTitle);
			}, typeof(string), typeof(string));
		}

		public override void Register()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			Achievements[Id] = this;
			if (Object.op_Implicit((Object)(object)GameManager.instance))
			{
				AchievementHandler achievementHandler = GameManager.instance.achievementHandler;
				_achievement = new Achievement
				{
					PlatformKey = Id,
					Type = AchievementType
				};
				List<Achievement> achievements = achievementHandler.achievementsList.achievements;
				int num = achievements.FindIndex((Achievement o) => o.PlatformKey == InsertBefore);
				if (num != -1)
				{
					achievements.Insert(num, _achievement);
				}
				else
				{
					achievements.Add(_achievement);
				}
				base.Register();
			}
		}

		protected override void OnReadySprite()
		{
			_achievement.Icon = Sprite;
		}

		public override void Unregister()
		{
			Achievements.Remove(Id);
			if (Object.op_Implicit((Object)(object)GameManager.instance))
			{
				GameManager.instance.achievementHandler.achievementsList.achievements.Remove(_achievement);
			}
		}
	}
	public class CustomCrest : SpriteItem
	{
		public class CrestSlot : WorkshopItem
		{
			public string CrestId = string.Empty;

			public ToolItemType ToolType = (ToolItemType)0;

			public AttackToolBinding Binding = (AttackToolBinding)0;

			public Vector2 Pos;

			public bool Lock;

			public override void Register()
			{
				WorkshopUI.RefreshIcon(this);
				if (Crests.TryGetValue(CrestId, out var value))
				{
					value._slots.Add(this);
					value.Unregister();
					value.Register();
				}
			}

			public override void Unregister()
			{
				if (Crests.TryGetValue(CrestId, out var value))
				{
					value._slots.Remove(this);
					value.Unregister();
					value.Register();
				}
			}

			public override Sprite GetIcon()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				return Object.op_Implicit((Object)(object)List) ? ((InventoryItemToolBase)List.crests.First().templateSlots[ToolType]).Sprite : SharerManager.Placeholder;
			}
		}

		public class CustomConfigGroup : ConfigGroup
		{
			public ToolCrest InheritsDashFrom;
		}

		private static readonly Dictionary<string, CustomCrest> Crests = new Dictionary<string, CustomCrest>();

		private ToolCrest _crest;

		public LocalStr Name = string.Empty;

		public LocalStr Desc = string.Empty;

		public LocalStr NamePrefix = string.Empty;

		public LocalStr EquipText = string.Empty;

		private readonly List<CrestSlot> _slots = new List<CrestSlot>();

		public string HIconUrl = string.Empty;

		public bool HPoint;

		public float HPpu = 100f;

		public string GIconUrl = string.Empty;

		public bool GPoint;

		public float GPpu = 100f;

		public string Movement = "Hunter";

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private static InventoryToolCrestList <List>k__BackingField;

		public override (string, string)[] FilesToDownload => new(string, string)[3]
		{
			(IconUrl, "png"),
			(HIconUrl, "png"),
			(GIconUrl, "png")
		};

		private static InventoryToolCrestList List
		{
			get
			{
				if (Object.op_Implicit((Object)(object)<List>k__BackingField))
				{
					return <List>k__BackingField;
				}
				return <List>k__BackingField = ((IEnumerable<InventoryToolCrestList>)Resources.FindObjectsOfTypeAll<InventoryToolCrestList>()).FirstOrDefault((Func<InventoryToolCrestList, bool>)((InventoryToolCrestList c) => c.crests.Count > 0));
			}
		}

		public static void Init()
		{
			typeof(HeroController).Hook("Start", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				CustomCrest[] array = Crests.Values.ToArray();
				foreach (CustomCrest customCrest in array)
				{
					customCrest.Unregister();
					customCrest.Register();
				}
				orig(self);
			});
			HookUtils.OnHeroAwake = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroAwake, (Action<HeroController>)delegate(HeroController controller)
			{
				PlayMakerFSM fsm = controller.sprintFSM;
				fsm.fsmTemplate = null;
				fsm.GetState("Start Attack").AddAction(delegate
				{
					if (controller.CurrentConfigGroup is CustomConfigGroup customConfigGroup)
					{
						PlayMakerFSM val = fsm;
						string name = customConfigGroup.InheritsDashFrom.name;
						if (1 == 0)
						{
						}
						string text = name switch
						{
							"Reaper" => "REAPER", 
							"Wanderer" => "WANDERER", 
							"Warrior" => "WARRIOR", 
							"Spell" => "SHAMAN", 
							"Toolmaster" => "TOOLMASTER", 
							_ => string.Empty, 
						};
						if (1 == 0)
						{
						}
						val.SendEvent(text);
					}
				}, 6, everyFrame: false);
			});
		}

		public override void Register()
		{
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			Crests[Id] = this;
			if (!Object.op_Implicit((Object)(object)HeroController.instance))
			{
				return;
			}
			_crest = ScriptableObject.CreateInstance<ToolCrest>();
			(HeroControllerConfig, ConfigGroup, ToolCrest) config = GetConfig(Movement);
			HeroControllerConfig item = config.Item1;
			ConfigGroup item2 = config.Item2;
			ToolCrest item3 = config.Item3;
			HeroControllerConfig val = Object.Instantiate<HeroControllerConfig>(item);
			CustomConfigGroup customConfigGroup = new CustomConfigGroup
			{
				InheritsDashFrom = item3,
				Config = val,
				ActiveRoot = item2.ActiveRoot,
				NormalSlashObject = item2.NormalSlashObject,
				AlternateSlashObject = item2.AlternateSlashObject,
				WallSlashObject = item2.WallSlashObject,
				UpSlashObject = item2.UpSlashObject,
				AltUpSlashObject = item2.AltUpSlashObject,
				DownSlashObject = item2.DownSlashObject,
				AltDownSlashObject = item2.AltDownSlashObject,
				DashStab = item2.DashStab,
				DashStabAlt = item2.DashStabAlt,
				ChargeSlash = item2.ChargeSlash,
				TauntSlash = item2.TauntSlash
			};
			bool activeSelf = item2.ActiveRoot.activeSelf;
			((ConfigGroup)customConfigGroup).Setup();
			if (activeSelf)
			{
				item2.ActiveRoot.SetActive(true);
			}
			List<ConfigGroup> list = HeroController.instance.configs.ToList();
			list.Add((ConfigGroup)(object)customConfigGroup);
			HeroController.instance.configs = list.ToArray();
			_crest.heroConfig = val;
			_crest.name = Id;
			_crest.displayName = Name;
			_crest.description = Desc;
			_crest.getPromptDesc = Desc;
			_crest.itemNamePrefix = NamePrefix;
			_crest.equipText = EquipText;
			_crest.slots = ((IEnumerable<CrestSlot>)_slots).Select((Func<CrestSlot, SlotInfo>)delegate(CrestSlot c)
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				int num = _slots.FirstPosMin((CrestSlot s) => s.Pos.y - c.Pos.y, Dist);
				int num2 = _slots.FirstPosMin((CrestSlot s) => c.Pos.y - s.Pos.y, Dist);
				int num3 = _slots.FirstPosMin((CrestSlot s) => c.Pos.x - s.Pos.x, Dist);
				int num4 = _slots.FirstPosMin((CrestSlot s) => s.Pos.x - c.Pos.x, Dist);
				SlotInfo result = default(SlotInfo);
				result.Position = c.Pos;
				result.Type = c.ToolType;
				result.AttackBinding = c.Binding;
				result.NavUpIndex = num;
				result.NavDownIndex = num2;
				result.NavLeftIndex = num3;
				result.NavRightIndex = num4;
				result.NavUpFallbackIndex = num;
				result.NavDownFallbackIndex = num2;
				result.NavLeftFallbackIndex = num3;
				result.NavRightFallbackIndex = num4;
				result.IsLocked = c.Lock;
				return result;
				float Dist(CrestSlot s)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					return Vector2.Distance(s.Pos, c.Pos);
				}
			}).ToArray();
			((NamedScriptableObjectList<ToolCrest>)(object)ManagerSingleton<ToolItemManager>.Instance.crestList).Add(_crest);
			WorkshopManager.CustomCrests.Add(Id, this);
			base.Register();
			RefreshHSprite();
			RefreshGSprite();
			if (PlayerData.instance.CurrentCrestID == Id)
			{
				ToolItemManager.AutoEquip(_crest, false, false);
			}
		}

		private void RefreshHSprite()
		{
			if (Utility.IsNullOrWhiteSpace(HIconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(HIconUrl, HPoint, HPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					_crest.crestSilhouette = sprites[0];
				}
			});
		}

		private void RefreshGSprite()
		{
			if (Utility.IsNullOrWhiteSpace(GIconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(GIconUrl, GPoint, GPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					_crest.crestGlow = sprites[0];
				}
			});
		}

		public override void Unregister()
		{
			((NamedScriptableObjectList<ToolCrest>)(object)ManagerSingleton<ToolItemManager>.Instance.crestList).Remove(_crest);
			WorkshopManager.CustomCrests.Remove(Id);
			if (!Object.op_Implicit((Object)(object)List))
			{
				return;
			}
			InventoryToolCrest val = ((IEnumerable<InventoryToolCrest>)List.crests).FirstOrDefault((Func<InventoryToolCrest, bool>)((InventoryToolCrest c) => (Object)(object)c.CrestData == (Object)(object)_crest));
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			List.crests.Remove(val);
			foreach (InventoryToolCrestSlot activeSlot in val.activeSlots)
			{
				((Component)activeSlot).gameObject.SetActive(false);
			}
			((Component)val.crestSprite).gameObject.SetActive(false);
			((Component)val.crestGlowSprite).gameObject.SetActive(false);
			((Component)val.crestSilhouette).gameObject.SetActive(false);
			Object.Destroy((Object)(object)val);
		}

		protected override void OnReadySprite()
		{
			_crest.crestSprite = Sprite;
		}

		private static (HeroControllerConfig, ConfigGroup, ToolCrest) GetConfig(string state)
		{
			ConfigGroup val = HeroController.instance.configs.First((ConfigGroup c) => ((Object)c.Config).name == "Default");
			if (1 == 0)
			{
			}
			(HeroControllerConfig, ToolCrest) tuple = state switch
			{
				"Reaper" => (Gameplay.ReaperCrest.heroConfig, Gameplay.ReaperCrest), 
				"Wanderer" => (Gameplay.WandererCrest.heroConfig, Gameplay.WandererCrest), 
				"Beast" => (Gameplay.WarriorCrest.heroConfig, Gameplay.WarriorCrest), 
				"Cloakless" => (Gameplay.CloaklessCrest.heroConfig, Gameplay.CloaklessCrest), 
				"Architect" => (Gameplay.ToolmasterCrest.heroConfig, Gameplay.ToolmasterCrest), 
				"Shaman" => (Gameplay.SpellCrest.heroConfig, Gameplay.SpellCrest), 
				"Cursed" => (Gameplay.CursedCrest.heroConfig, Gameplay.CursedCrest), 
				"Witch" => (Gameplay.WitchCrest.heroConfig, Gameplay.WitchCrest), 
				_ => (val.Config, Gameplay.HunterCrest), 
			};
			if (1 == 0)
			{
			}
			var (s, item) = tuple;
			return (s, ((IEnumerable<ConfigGroup>)HeroController.instance.configs).FirstOrDefault((Func<ConfigGroup, bool>)((ConfigGroup c) => (Object)(object)c.Config == (Object)(object)s)) ?? val, item);
		}
	}
	public class CustomCue : WorkshopItem
	{
		private static readonly Sprite Icon = ResourceUtils.LoadSpriteResource("audio_player", (FilterMode)1);

		private MusicCue _mcue;

		private AtmosCue _acue;

		private MusicChannelInfo _mci;

		private AtmosChannelInfo _aci;

		public string WavUrl = string.Empty;

		public bool IsAtmos;

		public override (string, string)[] FilesToDownload => new(string, string)[1] { (WavUrl, "wav") };

		public override void Register()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			if (IsAtmos)
			{
				_acue = ScriptableObject.CreateInstance<AtmosCue>();
				_aci = new AtmosChannelInfo();
				_acue.alternatives = Array.Empty<Alternative>();
				_acue.channelInfos = (AtmosChannelInfo[])(object)new AtmosChannelInfo[5]
				{
					_aci,
					new AtmosChannelInfo(),
					new AtmosChannelInfo(),
					new AtmosChannelInfo(),
					new AtmosChannelInfo()
				};
				((Object)_acue).name = Id;
				AudioPlayer.CustomAtmosCues.Add(Id, _acue);
			}
			else
			{
				_mcue = ScriptableObject.CreateInstance<MusicCue>();
				_mci = new MusicChannelInfo();
				_mcue.alternatives = Array.Empty<Alternative>();
				_mcue.channelInfos = (MusicChannelInfo[])(object)new MusicChannelInfo[6]
				{
					_mci,
					new MusicChannelInfo(),
					new MusicChannelInfo(),
					new MusicChannelInfo(),
					new MusicChannelInfo(),
					new MusicChannelInfo()
				};
				((Object)_mcue).name = Id;
				_mcue.originalMusicEventName = string.Empty;
				AudioPlayer.CustomMusicCues.Add(Id, _mcue);
			}
			RefreshSound();
		}

		private void RefreshSound()
		{
			if (Utility.IsNullOrWhiteSpace(WavUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSound(WavUrl, delegate(AudioClip wav)
			{
				wav.LoadAudioData();
				if (IsAtmos)
				{
					_aci.clip = wav;
				}
				else
				{
					_mci.clip = wav;
				}
			});
		}

		public override void Unregister()
		{
			if (Object.op_Implicit((Object)(object)_acue))
			{
				Object.Destroy((Object)(object)_acue);
			}
			if (Object.op_Implicit((Object)(object)_mcue))
			{
				Object.Destroy((Object)(object)_mcue);
			}
			AudioPlayer.CustomMusicCues.Remove(Id);
			AudioPlayer.CustomAtmosCues.Remove(Id);
		}

		public override Sprite GetIcon()
		{
			return Icon;
		}
	}
	public class CustomItem : SpriteItem
	{
		public interface ICustomItem
		{
			void Register(CustomItem item);

			void Unregister();

			void SetSprite(Sprite sprite)
			{
			}

			void SetAudio1(AudioClip clip)
			{
			}

			void SetAudio2(AudioClip clip)
			{
			}
		}

		public enum CustomItemType
		{
			Normal,
			Usable,
			Memento,
			Courier
		}

		public class CustomCollectable : CollectableItemMemento, ICustomItem
		{
			public string consumeEvent;

			public bool consume;

			private CustomItem _item;

			public override bool TakeItemOnConsume => consume;

			public override void ConsumeItemResponse()
			{
				if (!Utility.IsNullOrWhiteSpace(consumeEvent))
				{
					BroadcastBlock.DoBroadcast(consumeEvent);
				}
			}

			public void Register(CustomItem item)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				_item = item;
				((Object)this).name = item.Id;
				((CollectableItemBasic)this).displayName = item.ItemName;
				((CollectableItemBasic)this).description = item.ItemDesc;
				((CollectableItem)this).useResponseTextOverride = item.UseType;
				((CollectableItem)this).useResponses = (UseResponse[])(object)new UseResponse[1]
				{
					new UseResponse
					{
						UseType = (UseTypes)(item.ItemType == CustomItemType.Usable),
						Description = item.UseDesc
					}
				};
				((CollectableItem)this).customMaxAmount = item.MaxAmount;
				((CollectableItemBasic)this).setExtraPlayerDataBools = Array.Empty<PlayerDataBoolOperation>();
				((CollectableItemBasic)this).setExtraPlayerDataInts = Array.Empty<PlayerDataIntOperation>();
				((CollectableItem)this).isHidden = item.Hidden;
				consumeEvent = item.UseEvent;
				consume = item.Consume;
				((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).Add((CollectableItem)(object)this);
				if (Object.op_Implicit((Object)(object)MementoList) && _item.ItemType == CustomItemType.Memento)
				{
					((NamedScriptableObjectList<CollectableItemMemento>)(object)MementoList).Add((CollectableItemMemento)(object)this);
				}
			}

			public void SetSprite(Sprite sprite)
			{
				((CollectableItemBasic)this).icon = sprite;
			}

			public void SetAudio1(AudioClip clip)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				((CollectableItem)this).useSounds = new AudioEventRandom
				{
					Volume = _item.Volume1,
					PitchMax = _item.MaxPitch1,
					PitchMin = _item.MinPitch1,
					Clips = (AudioClip[])(object)new AudioClip[1] { clip }
				};
			}

			public void SetAudio2(AudioClip clip)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				((CollectableItem)this).instantUseSounds = new AudioEventRandom
				{
					Volume = _item.Volume2,
					PitchMax = _item.MaxPitch2,
					PitchMin = _item.MinPitch2,
					Clips = (AudioClip[])(object)new AudioClip[1] { clip }
				};
			}

			public override bool IsVisibleInCollection()
			{
				if (_item.ItemType == CustomItemType.Memento)
				{
					return ((CollectableItemMemento)this).IsVisibleInCollection();
				}
				return ((CollectableItem)this).CollectedAmount > 0;
			}

			public override string GetDescription(ReadSource readSource)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return LocalisedString.op_Implicit(((CollectableItemBasic)this).description);
			}

			public void Unregister()
			{
				((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).Remove((CollectableItem)(object)this);
				if (Object.op_Implicit((Object)(object)MementoList))
				{
					((NamedScriptableObjectList<CollectableItemMemento>)(object)MementoList).Remove((CollectableItemMemento)(object)this);
				}
				Object.Destroy((Object)(object)this);
			}
		}

		public class CustomCourierItem : DeliveryQuestItem, ICustomItem
		{
			public string consumeEvent;

			public bool consume;

			public int reward;

			public override bool TakeItemOnConsume => consume;

			public override void ConsumeItemResponse()
			{
				if (!Utility.IsNullOrWhiteSpace(consumeEvent))
				{
					BroadcastBlock.DoBroadcast(consumeEvent);
				}
			}

			public void Register(CustomItem item)
			{
				//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_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: 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_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_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				((Object)this).name = item.Id;
				base.displayName = item.ItemName;
				base.description = item.ItemDesc;
				((CollectableItem)this).useResponseTextOverride = item.UseType;
				((CollectableItem)this).useResponses = (UseResponse[])(object)new UseResponse[1]
				{
					new UseResponse
					{
						UseType = (UseTypes)0,
						Description = item.UseDesc
					}
				};
				((CollectableItem)this).customMaxAmount = item.MaxAmount;
				((CollectableItem)this).isHidden = item.Hidden;
				consumeEvent = item.UseEvent;
				consume = item.Consume;
				int courierEffects = item.CourierEffects;
				if (1 == 0)
				{
				}
				SavedItem val = (SavedItem)(courierEffects switch
				{
					0 => null, 
					1 => MiscUtils.GetSavedItem("Courier Supplies"), 
					2 => MiscUtils.GetSavedItem("Courier Supplies Slave"), 
					_ => MiscUtils.GetSavedItem("Courier Supplies Gourmand"), 
				});
				if (1 == 0)
				{
				}
				DeliveryQuestItem val2 = (DeliveryQuestItem)(object)((val is DeliveryQuestItem) ? val : null);
				if (Object.op_Implicit((Object)(object)val2))
				{
					base.breakHeroEffect = val2.breakHeroEffect;
					base.breakUIEffect = val2.breakUIEffect;
					base.heroLoopEffect = val2.heroLoopEffect;
					base.hitHeroEffect = val2.hitHeroEffect;
					base.hitUIEffect = val2.hitUIEffect;
					base.uiLoopEffect = val2.uiLoopEffect;
				}
				base.barColour = item.BarColour;
				base.totalTimer = item.Time;
				reward = item.RewardCost;
				((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).Add((CollectableItem)(object)this);
			}

			public void SetSprite(Sprite sprite)
			{
				base.icon = sprite;
			}

			public override bool IsVisibleInCollection()
			{
				return ((CollectableItem)this).CollectedAmount > 0;
			}

			public override string GetDescription(ReadSource readSource)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return LocalisedString.op_Implicit(base.description);
			}

			public void Unregister()
			{
				((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).Remove((CollectableItem)(object)this);
				Object.Destroy((Object)(object)this);
			}
		}

		private ICustomItem _item;

		public CustomItemType ItemType = CustomItemType.Normal;

		public LocalStr ItemName = string.Empty;

		public LocalStr ItemDesc = string.Empty;

		public LocalStr UseDesc = string.Empty;

		public int MaxAmount = int.MaxValue;

		public bool Hidden;

		public LocalStr UseType = "Break";

		public bool Consume;

		public string UseEvent;

		public int CourierEffects;

		public Color BarColour = Color.white;

		public int Time = 0;

		public int RewardCost = 0;

		public string WavURL1;

		public float Volume1 = 1f;

		public float MaxPitch1 = 1.2f;

		public float MinPitch1 = 0.8f;

		public string WavURL2;

		public float Volume2 = 1f;

		public float MaxPitch2 = 1.2f;

		public float MinPitch2 = 0.8f;

		private static CollectableItemMementoList _mementoList;

		public override (string, string)[] FilesToDownload => new(string, string)[3]
		{
			(IconUrl, "png"),
			(WavURL1, "wav"),
			(WavURL2, "wav")
		};

		public static CollectableItemMementoList MementoList
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)_mementoList))
				{
					_mementoList = Resources.FindObjectsOfTypeAll<CollectableItemMementoList>().FirstOrDefault();
				}
				return _mementoList;
			}
		}

		public override void Register()
		{
			if (ItemType == CustomItemType.Courier)
			{
				_item = ScriptableObject.CreateInstance<CustomCourierItem>();
			}
			else
			{
				_item = ScriptableObject.CreateInstance<CustomCollectable>();
			}
			_item.Register(this);
			WorkshopManager.CustomItems.Add(Id, this);
			base.Register();
			RefreshAudio1();
			RefreshAudio2();
			CollectableItemManager.IncrementVersion();
		}

		public override void Unregister()
		{
			WorkshopManager.CustomItems.Remove(Id);
			_item.Unregister();
			CollectableItemManager.IncrementVersion();
		}

		protected override void OnReadySprite()
		{
			_item.SetSprite(Sprite);
		}

		public void RefreshAudio1()
		{
			if (!Utility.IsNullOrWhiteSpace(WavURL1))
			{
				CustomAssetManager.DoLoadSound(WavURL1, delegate(AudioClip clip)
				{
					_item.SetAudio1(clip);
				});
			}
		}

		public void RefreshAudio2()
		{
			if (!Utility.IsNullOrWhiteSpace(WavURL2))
			{
				CustomAssetManager.DoLoadSound(WavURL2, delegate(AudioClip clip)
				{
					_item.SetAudio2(clip);
				});
			}
		}
	}
	public class CustomJournalEntry : SpriteItem
	{
		private EnemyJournalRecord _record;

		public string LIconUrl = string.Empty;

		public bool LPoint;

		public float LPpu = 100f;

		public LocalStr ItemName = string.Empty;

		public LocalStr ItemDesc = string.Empty;

		public LocalStr ItemHDesc = string.Empty;

		public string InsertBefore = string.Empty;

		public RequiredTypes Required = (RequiredTypes)1;

		public int KillsRequired = 1;

		public int Priority;

		public override int GetPriority()
		{
			return Priority;
		}

		public override void Register()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			_record = ScriptableObject.CreateInstance<EnemyJournalRecord>();
			((Object)_record).name = Id;
			_record.altNotesTest = new PlayerDataTest();
			_record.completeOthers = Array.Empty<EnemyJournalRecord>();
			_record.recordType = (RecordTypes)0;
			_record.killsRequired = KillsRequired;
			_record.displayName = ItemName;
			_record.description = ItemDesc;
			_record.notes = ItemHDesc;
			_record.requiredType = Required;
			List<EnemyJournalRecord> list = ((NamedScriptableObjectList<EnemyJournalRecord>)(object)EnemyJournalManager.Instance.recordList).List;
			int num = list.FindIndex((EnemyJournalRecord o) => ((Object)o).name == InsertBefore);
			if (num != -1)
			{
				list.Insert(num, _record);
			}
			else
			{
				list.Add(_record);
			}
			base.Register();
			RefreshLSprite();
			EnemyJournalRecord byName = ((NamedScriptableObjectList<EnemyJournalRecord>)(object)EnemyJournalManager.Instance.recordList).GetByName(Id);
			if (Object.op_Implicit((Object)(object)byName))
			{
				((NamedScriptableObjectList<EnemyJournalRecord>)(object)EnemyJournalManager.Instance.recordList).Remove(byName);
			}
			WorkshopManager.CustomEntries.Add(Id, this);
		}

		public void RefreshLSprite()
		{
			if (Utility.IsNullOrWhiteSpace(LIconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(LIconUrl, LPoint, LPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					_record.enemySprite = sprites[0];
				}
			});
		}

		protected override void OnReadySprite()
		{
			_record.iconSprite = Sprite;
		}

		public override void Unregister()
		{
			((NamedScriptableObjectList<EnemyJournalRecord>)(object)EnemyJournalManager.Instance.recordList).Remove(_record);
			WorkshopManager.CustomEntries.Remove(Id);
			Object.Destroy((Object)(object)_record);
		}
	}
	public class CustomKeybind : WorkshopItem
	{
		public class CustomKeyBindElement : KeyBindElement
		{
			public CustomKeybind Keybind;

			public CustomKeyBindElement(string label, [NotNull] IValueModel<KeyCode> model)
				: base(LocalizedText.op_Implicit(label), model)
			{
				((SelectableValueElement<KeyCode>)this).OnValueChanged += DoChange;
				((MenuDisposable)this).OnDispose += DoDispose;
			}

			public void DoChange(KeyCode code)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				GlobalArchitectData.Instance.Keybinds[Keybind.Id] = code;
			}

			public void DoDispose()
			{
				((SelectableValueElement<KeyCode>)this).OnValueChanged -= DoChange;
				((MenuDisposable)this).OnDispose -= DoDispose;
			}
		}

		private static readonly Sprite Icon = ResourceUtils.LoadSpriteResource("key_listener", (FilterMode)0);

		public static readonly Dictionary<string, CustomKeybind> Keybinds = new Dictionary<string, CustomKeybind>();

		public string Name = string.Empty;

		public KeyCode Default = (KeyCode)0;

		public override void Register()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!GlobalArchitectData.Instance.Keybinds.ContainsKey(Id) || Settings.TestMode.Value)
			{
				GlobalArchitectData.Instance.Keybinds[Id] = Default;
			}
			Keybinds.Add(Id, this);
		}

		public override void Unregister()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			Keybinds.Remove(Id);
			if (GlobalArchitectData.Instance.Keybinds.TryGetValue(Id, out var value) && (int)value == 0)
			{
				GlobalArchitectData.Instance.Keybinds.Remove(Id);
			}
		}

		public override Sprite GetIcon()
		{
			return Icon;
		}

		public static void Init()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			SimpleMenuScreen mapKeybinds = null;
			List<CustomKeyBindElement> keyButtons = new List<CustomKeyBindElement>();
			Registry.AddModMenu("Architect Map", (MenuElementGenerator)delegate
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				TextButton val = new TextButton(LocalizedText.Key(new LocalisedString("ArchitectMap", "ArchitectMap")));
				val.OnSubmit = (Action)Delegate.Combine(val.OnSubmit, (Action)delegate
				{
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_006c: Expected O, but got Unknown
					//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
					SimpleMenuScreen obj = mapKeybinds;
					if (obj != null)
					{
						((MenuDisposable)obj).Dispose();
					}
					foreach (CustomKeyBindElement item in keyButtons)
					{
						((MenuDisposable)item).Dispose();
					}
					keyButtons.Clear();
					mapKeybinds = new SimpleMenuScreen(GlobalArchitectData.Instance.MapLabel);
					MenuScreenNavigation.Show((AbstractMenuScreen)(object)mapKeybinds, (HistoryMode)0);
					foreach (KeyValuePair<string, CustomKeybind> keybind in Keybinds)
					{
						keybind.Deconstruct(out var key, out var value);
						string key2 = key;
						CustomKeybind customKeybind = value;
						CustomKeyBindElement customKeyBindElement = new CustomKeyBindElement(customKeybind.Name, (IValueModel<KeyCode>)(object)new ValueModel<KeyCode>(GlobalArchitectData.Instance.Keybinds[key2]))
						{
							Keybind = customKeybind
						};
						keyButtons.Add(customKeyBindElement);
						mapKeybinds.Add((MenuElement)(object)customKeyBindElement);
					}
				});
				return (SelectableElement)(object)val;
			});
		}
	}
	public class CustomMapIcon : SpriteItem
	{
		public class MapDisplayHandler : MonoBehaviour
		{
			public int mode;

			public string reqVar;

			public GameMapScene gms;

			private GameMap _gameMap;

			private Renderer _renderer;

			private void Reset()
			{
				_gameMap = ((Component)this).GetComponentInParent<GameMap>(true);
			}

			private void Awake()
			{
				_gameMap = ((Component)this).GetComponentInParent<GameMap>();
				_gameMap.UpdateQuickMapDisplay += Refresh;
				_renderer = ((Component)this).GetComponent<Renderer>();
			}

			private void Start()
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Invalid comparison between Unknown and I4
				if ((int)DisplayOnWorldMapOnly.updateState != 0)
				{
					Refresh((int)DisplayOnWorldMapOnly.updateState == 2, (MapZone)0);
				}
			}

			private void OnDestroy()
			{
				_gameMap.UpdateQuickMapDisplay -= Refresh;
			}

			private void Refresh(bool isQuickMap, MapZone _)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				DisplayOnWorldMapOnly.updateState = (UpdateState)((!isQuickMap) ? 1 : 2);
				if (Object.op_Implicit((Object)(object)_renderer))
				{
					_renderer.enabled = (mode == 0 || mode == 1 == isQuickMap) && ShouldBeVisible();
				}
			}

			private bool ShouldBeVisible()
			{
				if (!gms.IsMapped)
				{
					return false;
				}
				if (Utility.IsNullOrWhiteSpace(reqVar))
				{
					return true;
				}
				bool value;
				return ArchitectData.Instance.BoolVariables.TryGetValue(reqVar, out value) && value;
			}
		}

		public static readonly List<CustomMapIcon> Icons = new List<CustomMapIcon>();

		public string Scene = string.Empty;

		public Vector2 Pos = Vector2.zero;

		public int Mode;

		public string Text = string.Empty;

		public float FontSize = 6.2f;

		public Vector2 Offset = Vector2.zero;

		public Color Colour = Color.white;

		public string ReqVar;

		private GameObject _iconObj;

		private SpriteRenderer _renderer;

		public override void Register()
		{
			Icons.Add(this);
			Setup();
			base.Register();
		}

		public override void Unregister()
		{
			Icons.Remove(this);
			if (Object.op_Implicit((Object)(object)_iconObj))
			{
				Object.Destroy((Object)(object)_iconObj);
			}
		}

		public void Setup()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_010d: Unknown result type (might be due to invalid IL or missing references)
			if (SceneUtils.CustomScenes.TryGetValue(Scene, out var value) && Object.op_Implicit((Object)(object)value.Map))
			{
				_iconObj = Object.Instantiate<GameObject>(SceneGroup.MapIconPrefab, value.Map.transform);
				_iconObj.transform.localPosition = Vector2.op_Implicit(Pos);
				Extensions.SetLocalPositionZ(_iconObj.transform, -0.2f);
				_iconObj.transform.GetChild(0).localPosition = Vector2.op_Implicit(Offset);
				((Renderer)_iconObj.GetComponentInChildren<MeshRenderer>()).sortingOrder = 11;
				_renderer = _iconObj.GetComponentInChildren<SpriteRenderer>();
				((Renderer)_renderer).sortingOrder = 11;
				_iconObj.GetComponentInChildren<SetTextMeshProGameText>().text = (LocalStr)Text;
				TextMeshPro componentInChildren = _iconObj.GetComponentInChildren<TextMeshPro>();
				((TMP_Text)componentInChildren).fontSize = FontSize;
				((Graphic)componentInChildren).color = Colour;
				MapDisplayHandler mapDisplayHandler = ((Component)_iconObj.transform.GetChild(0)).gameObject.AddComponent<MapDisplayHandler>();
				MapDisplayHandler mapDisplayHandler2 = ((Component)_iconObj.transform.GetChild(1)).gameObject.AddComponent<MapDisplayHandler>();
				mapDisplayHandler.mode = Mode;
				mapDisplayHandler.reqVar = (mapDisplayHandler2.reqVar = ReqVar);
				mapDisplayHandler.gms = (mapDisplayHandler2.gms = value.Gms);
				_renderer.sprite = Sprite;
				_iconObj.SetActive(true);
			}
		}

		protected override void OnReadySprite()
		{
			if (Object.op_Implicit((Object)(object)_renderer))
			{
				_renderer.sprite = Sprite;
			}
		}
	}
	public class CustomMateriumEntry : SpriteItem
	{
		private MateriumItem _item;

		public LocalStr ItemName = string.Empty;

		public LocalStr Desc = string.Empty;

		public string InsertBefore = string.Empty;

		public override void Register()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			_item = ScriptableObject.CreateInstance<MateriumItem>();
			((Object)_item).name = Id;
			_item.itemQuests = new List<Quest>();
			_item.playerDataCondition = new PlayerDataTest();
			_item.displayName = ItemName;
			_item.description = Desc;
			List<MateriumItem> list = ((NamedScriptableObjectList<MateriumItem>)(object)ManagerSingleton<MateriumItemManager>.Instance.masterList).List;
			int num = list.FindIndex((MateriumItem o) => ((Object)o).name == InsertBefore);
			if (num != -1)
			{
				list.Insert(num, _item);
			}
			else
			{
				list.Add(_item);
			}
			((NamedScriptableObjectList<MateriumItem>)(object)ManagerSingleton<MateriumItemManager>.Instance.masterList).UpdateDictionary();
			base.Register();
		}

		public override void Unregister()
		{
			((NamedScriptableObjectList<MateriumItem>)(object)ManagerSingleton<MateriumItemManager>.Instance.masterList).Remove(_item);
			((NamedScriptableObjectList<MateriumItem>)(object)ManagerSingleton<MateriumItemManager>.Instance.masterList).UpdateDictionary();
			Object.Destroy((Object)(object)_item);
		}

		protected override void OnReadySprite()
		{
			_item.icon = Sprite;
		}
	}
	public class CustomMenuStyle : WorkshopItem
	{
		public class FakePlayer : MonoBehaviour
		{
			private HeroController _hc;

			private void Start()
			{
				_hc = ((Component)this).GetComponent<HeroController>();
			}

			private void Update()
			{
				_hc.ResetHardLandingTimer();
				_hc.RelinquishControl();
				Extensions.SetPosition2D(((Component)this).transform, 9999999f, 9999999f);
			}
		}

		public class LoadSceneContents : MonoBehaviour
		{
			public string id;

			private Scene _scene;

			public void OnEnable()
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				_scene = SceneManager.CreateScene(id + "_Title");
				LevelData levelData = StorageManager.LoadScene(id + "_Title");
				foreach (ObjectPlacement placement in levelData.Placements)
				{
					GameObject val = placement.SpawnObject();
					if (Object.op_Implicit((Object)(object)val))
					{
						SceneManager.MoveGameObjectToScene(val, _scene);
						PlacementManager.Objects[placement.GetId()] = val;
						PlacementManager.OnPlace?.Invoke(placement.GetPlacementType().GetId(), placement.GetId(), val);
					}
				}
				foreach (ScriptBlock scriptBlock in levelData.ScriptBlocks)
				{
					scriptBlock.Setup(visual: false);
				}
				foreach (ScriptBlock scriptBlock2 in levelData.ScriptBlocks)
				{
					scriptBlock2.LateSetup();
				}
			}

			private void OnDisable()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				SceneManager.UnloadSceneAsync(_scene);
			}
		}

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

			private object <>2__current;

			public GameObject obj;

			private AsyncOperationHandle<GameObject> <hero>5__1;

			private GameObject <player>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				<hero>5__1 = default(AsyncOperationHandle<GameObject>);
				<player>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<hero>5__1 = GameManager.instance.LoadHeroPrefab();
					<>2__current = <hero>5__1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<player>5__2 = Object.Instantiate<GameObject>(<hero>5__1.Result, obj.transform);
					<player>5__2.AddComponent<FakePlayer>();
					return false;
				}
			}

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

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

		private static readonly List<CustomMenuStyle> Styles = new List<CustomMenuStyle>();

		private static GameObject _ms;

		private GameObject _parent;

		public static void Init()
		{
			typeof(MenuStyles).Hook("Start", (Action<Action<MenuStyles>, MenuStyles>)delegate(Action<MenuStyles> orig, MenuStyles self)
			{
				orig(self);
				_ms = ((Component)self).gameObject;
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadHero(((Component)self).gameObject));
				CustomMenuStyle[] array = Styles.ToArray();
				foreach (CustomMenuStyle customMenuStyle in array)
				{
					customMenuStyle.Unregister();
					customMenuStyle.Register();
				}
			});
			typeof(GameManager).Hook("LoadHeroPrefab", (Func<Func<GameManager, AsyncOperationHandle<GameObject>>, GameManager, AsyncOperationHandle<GameObject>>)delegate(Func<GameManager, AsyncOperationHandle<GameObject>> orig, GameManager self)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)HeroController._instance))
				{
					((Component)HeroController._instance).gameObject.RemoveComponent<FakePlayer>();
				}
				return orig(self);
			});
		}

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

		public override void Register()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			Styles.Add(this);
			if (Object.op_Implicit((Object)(object)_ms))
			{
				GameObject val = new GameObject(Id);
				val.transform.parent = _ms.transform;
				val.transform.localPosition = new Vector3(-5f, -7.8454f, 3.5469f);
				_parent = val;
				_parent.SetActive(false);
				LoadSceneContents loadSceneContents = _parent.AddComponent<LoadSceneContents>();
				loadSceneContents.id = Id;
			}
		}

		public override void Unregister()
		{
			Styles.Remove(this);
			if (Object.op_Implicit((Object)(object)_parent))
			{
				Object.Destroy((Object)(object)_parent);
			}
		}

		public override Sprite GetIcon()
		{
			return ArchitectPlugin.BlankSprite;
		}
	}
	public class CustomNeedle : SpriteItem
	{
		public static readonly Dictionary<string, CustomNeedle> Needles = new Dictionary<string, CustomNeedle>();

		private static InventoryItemNail _nail;

		private static GameObject _nailPrefab;

		private DisplayState _displayState;

		public int Damage;

		public LocalStr Name = string.Empty;

		public LocalStr Desc = string.Empty;

		public float NeedleRangeMult = 1f;

		public int NeedleColourActive = 0;

		public Color NeedleColour = Color.white;

		public static void Init()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			typeof(InventoryItemNail).Hook("Awake", (Action<Action<InventoryItemNail>, InventoryItemNail>)delegate(Action<InventoryItemNail> orig, InventoryItemNail self)
			{
				orig(self);
				_nail = self;
				_nailPrefab = _nail.displayStates[4].DisplayObject;
				foreach (CustomNeedle value5 in Needles.Values)
				{
					value5.Register();
				}
			});
			typeof(InventoryItemNail).Hook("UpdateState", (Action<Action<InventoryItemNail>, InventoryItemNail>)delegate(Action<InventoryItemNail> orig, InventoryItemNail self)
			{
				orig(self);
				string customNeedle4 = ArchitectData.Instance.CustomNeedle;
				if (!Utility.IsNullOrWhiteSpace(customNeedle4) && Needles.TryGetValue(customNeedle4, out var value4))
				{
					DisplayState[] displayStates = self.displayStates;
					foreach (DisplayState val5 in displayStates)
					{
						if (Object.op_Implicit((Object)(object)val5.DisplayObject))
						{
							val5.DisplayObject.SetActive(false);
						}
					}
					self.currentState = value4._displayState;
					value4._displayState.DisplayObject.SetActive(true);
				}
			});
			new Hook((MethodBase)typeof(PlayerData).GetProperty("nailDamage").GetGetMethod(), (Delegate)(Func<Func<PlayerData, int>, PlayerData, int>)delegate(Func<PlayerData, int> orig, PlayerData self)
			{
				string customNeedle3 = ArchitectData.Instance.CustomNeedle;
				CustomNeedle value3;
				return (!Utility.IsNullOrWhiteSpace(customNeedle3) && Needles.TryGetValue(customNeedle3, out value3)) ? value3.Damage : orig(self);
			});
			typeof(NailAttackBase).Hook("OnSlashStarting", (Action<Action<NailAttackBase>, NailAttackBase>)delegate(Action<NailAttackBase> orig, NailAttackBase self)
			{
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: 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_00ce: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
				string customNeedle2 = ArchitectData.Instance.CustomNeedle;
				if (!Utility.IsNullOrWhiteSpace(customNeedle2) && Needles.TryGetValue(customNeedle2, out var value2))
				{
					if (value2.NeedleColourActive == 1)
					{
						if (Object.op_Implicit((Object)(object)self.slashSprite))
						{
							((tk2dBaseSprite)self.slashSprite).color = value2.NeedleColour;
						}
						if (Object.op_Implicit((Object)(object)self.imbuedSlashAnim))
						{
							((tk2dBaseSprite)self.imbuedSlashSprite).color = value2.NeedleColour;
						}
					}
					orig(self);
					Transform transform = ((Component)self).transform;
					transform.localScale *= value2.NeedleRangeMult;
					if (value2.NeedleColourActive == 2)
					{
						if (Object.op_Implicit((Object)(object)self.slashSprite))
						{
							((tk2dBaseSprite)self.slashSprite).color = value2.NeedleColour;
						}
						if (Object.op_Implicit((Object)(object)self.imbuedSlashAnim))
						{
							((tk2dBaseSprite)self.imbuedSlashSprite).color = value2.NeedleColour;
						}
					}
				}
				else
				{
					orig(self);
				}
			});
			typeof(HeroExtraNailSlash).Hook("OnEnable", (Action<Action<HeroExtraNailSlash>, HeroExtraNailSlash>)delegate(Action<HeroExtraNailSlash> orig, HeroExtraNailSlash self)
			{
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				string customNeedle = ArchitectData.Instance.CustomNeedle;
				if (!Utility.IsNullOrWhiteSpace(customNeedle) && Needles.TryGetValue(customNeedle, out var value))
				{
					if (value.NeedleColourActive == 1)
					{
						SpriteRenderer[] tintSprites = self.tintSprites;
						foreach (SpriteRenderer val in tintSprites)
						{
							if (Object.op_Implicit((Object)(object)val))
							{
								val.color = value.NeedleColour;
							}
						}
						tk2dSprite[] tintTk2dSprites = self.tintTk2dSprites;
						foreach (tk2dSprite val2 in tintTk2dSprites)
						{
							if (Object.op_Implicit((Object)(object)val2))
							{
								((tk2dBaseSprite)val2).color = value.NeedleColour;
							}
						}
					}
					orig(self);
					if (value.NeedleColourActive == 2)
					{
						SpriteRenderer[] tintSprites2 = self.tintSprites;
						foreach (SpriteRenderer val3 in tintSprites2)
						{
							if (Object.op_Implicit((Object)(object)val3))
							{
								val3.color = value.NeedleColour;
							}
						}
						tk2dSprite[] tintTk2dSprites2 = self.tintTk2dSprites;
						foreach (tk2dSprite val4 in tintTk2dSprites2)
						{
							if (Object.op_Implicit((Object)(object)val4))
							{
								((tk2dBaseSprite)val4).color = value.NeedleColour;
							}
						}
					}
				}
				else
				{
					orig(self);
				}
			});
		}

		public override void Register()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			if (!Needles.ContainsKey(Id))
			{
				Needles[Id] = this;
			}
			if (Object.op_Implicit((Object)(object)_nail))
			{
				GameObject val = Object.Instantiate<GameObject>(_nailPrefab, ((Component)_nail).transform);
				((Object)val).name = Id;
				_displayState = new DisplayState
				{
					DisplayObject = val,
					DisplayName = Name,
					Description = Desc
				};
				List<DisplayState> list = _nail.displayStates.ToList();
				list.Add(_displayState);
				_nail.displayStates = list.ToArray();
				base.Register();
			}
		}

		public override void Unregister()
		{
			if (Object.op_Implicit((Object)(object)_nail))
			{
				List<DisplayState> list = _nail.displayStates.ToList();
				list.Remove(_displayState);
				_nail.displayStates = list.ToArray();
				Object.Destroy((Object)(object)_displayState.DisplayObject);
			}
			Needles.Remove(Id);
		}

		protected override void OnReadySprite()
		{
			_displayState.DisplayObject.GetComponent<SpriteRenderer>().sprite = Sprite;
		}
	}
	public class CustomQuest : SpriteItem
	{
		public bool MainQuest;

		public LocalStr ItemName = string.Empty;

		public LocalStr ItemDesc = string.Empty;

		public LocalStr WallDesc = string.Empty;

		public LocalStr TypeName = string.Empty;

		public Color Color = Color.white;

		private MainQuest _mq;

		private FullQuestBase _quest;

		private QuestType _type;

		public string LIconUrl = string.Empty;

		public bool LPoint;

		public float LPpu = 100f;

		public string GIconUrl = string.Empty;

		public bool GPoint;

		public float GPpu = 100f;

		public bool HasItem;

		public string ItemId = string.Empty;

		public int ItemCount = 1;

		public DescCounterTypes DescCounterType = (DescCounterTypes)0;

		public ListCounterTypes ListCounterType = (ListCounterTypes)0;

		public Color BarColour = Color.white;

		public LocalStr CollectedDesc = string.Empty;

		public override (string, string)[] FilesToDownload => new(string, string)[3]
		{
			(IconUrl, "png"),
			(LIconUrl, "png"),
			(GIconUrl, "png")
		};

		public override int GetPriority()
		{
			return 1;
		}

		public override void Register()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Expected O, but got Unknown
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			_type = QuestType.Create((LocalisedString)TypeName, (Sprite)null, Color, (Sprite)null, (Sprite)null, (Sprite)null);
			if (MainQuest)
			{
				_mq = ScriptableObject.CreateInstance<MainQuest>();
				_mq.questType = _type;
				_mq.subQuests = Array.Empty<SubQuest>();
				_mq.altTargets = Array.Empty<AltQuestTarget>();
				_quest = (FullQuestBase)(object)_mq;
			}
			else
			{
				Quest val = ScriptableObject.CreateInstance<Quest>();
				val.questType = _type;
				_quest = (FullQuestBase)(object)val;
			}
			((Object)_quest).name = Id;
			_quest.hideDescCounterForLangs = Array.Empty<LanguageCode>();
			_quest.persistentBoolTests = Array.Empty<PersistentBoolTest>();
			_quest.requiredCompleteQuests = Array.Empty<FullQuestBase>();
			_quest.requiredUnlockedTools = Array.Empty<ToolItem>();
			_quest.requiredCompleteTotalGroups = Array.Empty<QuestCompleteTotalGroup>();
			_quest.markCompleted = Array.Empty<FullQuestBase>();
			_quest.cancelIfIncomplete = Array.Empty<FullQuestBase>();
			_quest.hideIfComplete = Array.Empty<FullQuestBase>();
			_quest.playerDataTest = new PlayerDataTest();
			((BasicQuestBase)_quest).displayName = ItemName;
			_quest.inventoryDescription = ItemDesc;
			_quest.inventoryCompletableDescription = ItemDesc;
			_quest.wallDescription = WallDesc;
			_quest.descCounterType = DescCounterType;
			_quest.listCounterType = ListCounterType;
			_quest.progressBarTint = BarColour;
			List<QuestTarget> list = new List<QuestTarget>();
			if (HasItem)
			{
				_quest.inventoryCompletableDescription = CollectedDesc;
				string[] ic = ItemId.Split(",");
				Dictionary<string, int> dictionary = ic.Distinct().ToDictionary((string i) => i, (string i) => ic.Count((string o) => o == i));
				foreach (KeyValuePair<string, int> item in dictionary)
				{
					item.Deconstruct(out var key, out var value);
					string name = key;
					int num = value;
					SavedItem savedItem = MiscUtils.GetSavedItem(name);
					CollectableItem val2 = (CollectableItem)(object)((savedItem is CollectableItem) ? savedItem : null);
					if (Object.op_Implicit((Object)(object)val2))
					{
						list.Add(new QuestTarget
						{
							Counter = (QuestTargetCounter)(object)val2,
							Count = ItemCount / ic.Length * num,
							AltTest = new PlayerDataTest(),
							ItemName = (LocalStr)val2.GetDisplayName((ReadSource)0)
						});
					}
				}
			}
			_quest.targets = list.ToArray();
			_quest.overrideFontSize = new OverrideFloat();
			_quest.overrideParagraphSpacing = new OverrideFloat();
			_quest.overrideParagraphSpacingShort = new OverrideFloat();
			((NamedScriptableObjectList<BasicQuestBase>)(object)QuestManager.Instance.masterList).Add((BasicQuestBase)(object)_quest);
			base.Register();
			RefreshLSprite();
			RefreshGSprite();
			QuestManager.IncrementVersion();
			WorkshopManager.CustomQuests.Add(Id, this);
		}

		public override void Unregister()
		{
			((NamedScriptableObjectList<BasicQuestBase>)(object)QuestManager.Instance.masterList).Remove((BasicQuestBase)(object)_quest);
			QuestManager.IncrementVersion();
			Object.Destroy((Object)(object)_quest);
			WorkshopManager.CustomQuests.Remove(Id);
		}

		protected override void OnReadySprite()
		{
			_type.icon = Sprite;
			if (Object.op_Implicit((Object)(object)_mq))
			{
				_mq.typeIcon = Sprite;
			}
		}

		public void RefreshLSprite()
		{
			if (Utility.IsNullOrWhiteSpace(LIconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(LIconUrl, LPoint, LPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					_type.largeIcon = sprites[0];
					if (Object.op_Implicit((Object)(object)_mq))
					{
						_mq.typeLargeIcon = sprites[0];
					}
				}
			});
		}

		public void RefreshGSprite()
		{
			if (Utility.IsNullOrWhiteSpace(GIconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(GIconUrl, GPoint, GPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					_type.largeIconGlow = sprites[0];
					if (Object.op_Implicit((Object)(object)_mq))
					{
						_mq.typeLargeIconGlow = sprites[0];
					}
				}
			});
		}
	}
	public class CustomScene : SpriteItem
	{
		public string Group = "None";

		public int TilemapWidth = 500;

		public int TilemapHeight = 500;

		public Vector2 MapPos;

		public string EIconUrl = string.Empty;

		public bool EPoint;

		public float EPpu = 100f;

		public EnvironmentTypes Environment = (EnvironmentTypes)0;

		public bool OverrideColour;

		public Color MapColour = Color.white;

		public GameObject Map;

		public GameMapScene Gms;

		private Sprite _is;

		public override (string, string)[] FilesToDownload => new(string, string)[2]
		{
			(IconUrl, "png"),
			(EIconUrl, "png")
		};

		public override void Register()
		{
			SceneUtils.CustomScenes[Id] = this;
			if (Object.op_Implicit((Object)(object)Map))
			{
				Object.Destroy((Object)(object)Map);
			}
			TrySetupMap();
			if (SceneUtils.QWHookEnabled)
			{
				QuickWarpHookLoader.RegisterScene(Group, Id);
			}
		}

		public void TrySetupMap()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (!SceneUtils.SceneGroups.TryGetValue(Group, out var value) || !Object.op_Implicit((Object)(object)value.FocusMapObject))
			{
				return;
			}
			Map = Object.Instantiate<GameObject>(SceneGroup.MapSegmentPrefab, value.FocusMapObject.transform);
			((Object)Map).name = Id;
			Map.SetActive(true);
			Map.transform.localPosition = Vector2.op_Implicit(MapPos);
			Gms = Map.GetComponent<GameMapScene>();
			Gms.initialColor = value.MapColour;
			Gms.fullSprite = null;
			Gms.initialSprite = null;
			Gms.initialState = (States)1;
			Gms.spriteRenderer = ((Component)Gms).GetComponent<SpriteRenderer>();
			Gms.hasSpriteRenderer = true;
			Gms.spriteRenderer.color = (OverrideColour ? MapColour : value.MapColour);
			Gms.spriteRenderer.sprite = null;
			RefreshSprite();
			RefreshESprite();
			foreach (CustomMapIcon item in CustomMapIcon.Icons.Where((CustomMapIcon i) => i.Scene == Id))
			{
				item.Setup();
			}
			RefreshMap();
		}

		private void RefreshMap()
		{
			if (Object.op_Implicit((Object)(object)Gms))
			{
				PlayerData instance = PlayerData.instance;
				Gms.initialSprite = _is;
				Gms.fullSprite = Sprite;
				Gms.hasBeenSet = false;
				if ((Gms.isMapped || instance.scenesVisited.Contains(Id)) && SceneUtils.SceneGroups.TryGetValue(Group, out var value) && value.HasMapZone && !CollectableItemManager.IsInHiddenMode() && instance.hasQuill)
				{
					Gms.SetMapped();
				}
				else
				{
					Gms.SetNotMapped();
				}
				if (Object.op_Implicit((Object)(object)GameManager.instance.gameMap))
				{
					GameManager.instance.gameMap.CalculateMapScrollBounds();
				}
			}
		}

		public void RefreshESprite()
		{
			if (!Object.op_Implicit((Object)(object)Gms))
			{
				return;
			}
			if (Utility.IsNullOrWhiteSpace(EIconUrl))
			{
				RefreshMap();
				return;
			}
			CustomAssetManager.DoLoadSprite(EIconUrl, EPoint, EPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					_is = sprites[0];
					RefreshMap();
				}
			});
		}

		protected override void OnReadySprite()
		{
			RefreshMap();
		}

		public override void Unregister()
		{
			SceneUtils.CustomScenes.Remove(Id);
			if (Object.op_Implicit((Object)(object)Map))
			{
				Object.Destroy((Object)(object)Map);
			}
			if (SceneUtils.QWHookEnabled)
			{
				QuickWarpHookLoader.UnregisterScene(Group, Id);
			}
			if (Object.op_Implicit((Object)(object)GameManager.instance.gameMap))
			{
				GameManager.instance.gameMap.CalculateMapScrollBounds();
			}
		}
	}
	public class CustomTool : SpriteItem
	{
		public class CustomToolItem : ToolItemBasic
		{
			public Sprite fullSprite;

			public int cost = 5;

			public override Sprite GetHudSprite(IconVariants iconVariant)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				Sprite hudSprite = ((ToolItemBasic)this).GetHudSprite(iconVariant);
				if (!((ToolItem)this).IsEmpty)
				{
					return fullSprite ?? hudSprite;
				}
				return hudSprite;
			}

			public override bool TryReplenishSingle(bool doReplenish, float inCost, out float outCost, out int reserveCost)
			{
				((ToolItem)this).TryReplenishSingle(doReplenish, inCost, ref outCost, ref reserveCost);
				outCost = cost;
				return true;
			}
		}

		public class CustomLiquidToolItem : ToolItemStatesLiquid
		{
			public Sprite fullSprite;

			public int cost = 5;

			public override Sprite GetHudSprite(IconVariants iconVariant)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				Sprite hudSprite = ((ToolItemStates)this).GetHudSprite(iconVariant);
				if (!((ToolItem)this).IsEmpty)
				{
					return fullSprite ?? hudSprite;
				}
				return hudSprite;
			}

			public override bool TryReplenishSingle(bool doReplenish, float inCost, out float outCost, out int reserveCost)
			{
				((ToolItemStatesLiquid)this).TryReplenishSingle(doReplenish, inCost, ref outCost, ref reserveCost);
				outCost = cost;
				return true;
			}
		}

		private ToolItemBasic _tool;

		public static readonly List<string> List = new List<string>();

		public LocalStr ItemName = string.Empty;

		public LocalStr ItemDesc = string.Empty;

		public ToolItemType ItemType = (ToolItemType)0;

		public bool IsLiquid;

		public string HIconUrl = string.Empty;

		public bool HPoint;

		public float HPpu = 100f;

		public string GIconUrl = string.Empty;

		public bool GPoint;

		public float GPpu = 100f;

		public int RepairCost = 5;

		public bool PreventIncrease;

		public int MaxAmount = 10;

		public override (string, string)[] FilesToDownload => new(string, string)[3]
		{
			(IconUrl, "png"),
			(HIconUrl, "png"),
			(GIconUrl, "png")
		};

		public override void Register()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Invalid comparison between Unknown and I4
			List.Add(Id);
			_tool = (ToolItemBasic)(object)(((int)ItemType == 3) ? ((CustomToolItem)(object)ScriptableObject.CreateInstance<ToolItemSkill>()) : ScriptableObject.CreateInstance<CustomToolItem>());
			_tool.usageOptions.FsmEventName = "";
			((ToolItem)_tool).name = Id;
			((ToolItem)_tool).type = ItemType;
			_tool.displayName = ItemName;
			_tool.description = ItemDesc;
			((ToolItem)_tool).alternateUnlockedTest = new PlayerDataTest();
			((ToolItem)_tool).preventStorageIncrease = PreventIncrease;
			if ((int)ItemType == 0)
			{
				((ToolItem)_tool).baseStorageAmount = MaxAmount;
			}
			if (_tool is CustomToolItem customToolItem)
			{
				customToolItem.cost = RepairCost;
			}
			((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).Add((ToolItem)(object)_tool);
			WorkshopManager.CustomTools.Add(Id, this);
			ToolItemManager.IncrementVersion();
			base.Register();
			RefreshHSprite();
			RefreshGSprite();
		}

		protected override void OnReadySprite()
		{
			_tool.inventorySprite = Sprite;
		}

		public override void Unregister()
		{
			List.Remove(Id);
			((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).Remove((ToolItem)(object)_tool);
			WorkshopManager.CustomTools.Remove(Id);
			ToolItemManager.IncrementVersion();
		}

		public void RefreshHSprite()
		{
			if (Utility.IsNullOrWhiteSpace(HIconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(HIconUrl, HPoint, HPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					_tool.hudSprite = sprites[0];
				}
			});
		}

		public void RefreshGSprite()
		{
			if (Utility.IsNullOrWhiteSpace(GIconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(GIconUrl, GPoint, GPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					ToolItemBasic tool = _tool;
					ToolItemBasic val = tool;
					ToolItemSkill val2 = (ToolItemSkill)(object)((val is ToolItemSkill) ? val : null);
					if (val2 == null)
					{
						if (val is CustomToolItem customToolItem)
						{
							customToolItem.fullSprite = sprites[0];
						}
					}
					else
					{
						val2.hudGlowSprite = sprites[0];
					}
				}
			});
		}
	}
	public class SceneGroup : SpriteItem
	{
		public delegate bool HasMapForScene(GameMap self, string sceneName, out bool hasSceneSprite);

		public class CustomMapZone : MonoBehaviour
		{
			public SceneGroup SceneGroup;

			public void OnEnable()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				if (SceneGroup != null)
				{
					SceneGroup.MapZone.initialColor = SceneGroup.MapColour;
					SceneGroup.MapZone.initialLabelColor = Color.white;
				}
			}
		}

		public string GroupName = string.Empty;

		public bool DisableAct3Bg;

		public Vector2 MapPos;

		public Vector2 LabelPos;

		public Vector2 ZoomPos;

		public Vector2 AreaNamePos;

		public string Variable = string.Empty;

		public float Radius = 0.2f;

		public bool HasMapZone;

		public Color MapColour = Color.white;

		public string MapUrl = string.Empty;

		public bool MPoint;

		public float MPpu = 100f;

		public readonly string[] OverwriteEnter = new string[4] { "", "", "", "" };

		public readonly string[] OverwriteExit = new string[4] { "", "", "", "" };

		public Sprite MapSprite;

		public AreaBackground Background;

		private static InventoryWideMap _wideMap;

		public static GameObject MapSegmentPrefab;

		public static GameObject MapIconPrefab;

		private static GameObject _areaTextPrefab;

		public InventoryItemWideMapZone MapZone;

		private GameObject _mapObject;

		public GameObject FocusMapObject;

		private static readonly int UILayer = LayerMask.NameToLayer("UI");

		public override (string, string)[] FilesToDownload => new(string, string)[2]
		{
			(IconUrl, "png"),
			(MapUrl, "png")
		};

		public static void Init()
		{
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			PreloadManager.RegisterPreload(new BasicPreload("maps_assets_all", "Assets/Prefabs/UI/Map/Game_Map_Hornet.prefab", delegate(GameObject o)
			{
				GameObject gameObject = ((Component)o.transform.Find("Tut").Find("Tut_02")).gameObject;
				gameObject.SetActive(false);
				MapSegmentPrefab = Object.Instantiate<GameObject>(gameObject);
				gameObject.SetActive(true);
				Object.DontDestroyOnLoad((Object)(object)MapSegmentPrefab);
				GameObject gameObject2 = ((Component)o.transform.Find("Tut").Find("Area Name (2)")).gameObject;
				gameObject2.SetActive(false);
				_areaTextPrefab = Object.Instantiate<GameObject>(gameObject2);
				gameObject2.SetActive(true);
				Object.DontDestroyOnLoad((Object)(object)_areaTextPrefab);
				GameObject gameObject3 = ((Component)o.transform.Find("Tut").Find("Tut_01").Find("Next Area Up (2)")).gameObject;
				gameObject3.SetActive(false);
				MapIconPrefab = Object.Instantiate<GameObject>(gameObject3);
				gameObject3.SetActive(true);
				Object.DontDestroyOnLoad((Object)(object)MapIconPrefab);
			}, notSceneBundle: true));
			typeof(GameMap).Hook("SetupMap", (Action<Action<GameMap, bool>, GameMap, bool>)delegate(Action<GameMap, bool> orig, GameMap self, bool pinsOnly)
			{
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				orig(self, pinsOnly);
				PlayerData instance = PlayerData.instance;
				foreach (var (item, customScene2) in SceneUtils.CustomScenes)
				{
					if (Object.op_Implicit((Object)(object)customScene2.Gms))
					{
						if ((customScene2.Gms.isMapped || instance.scenesVisited.Contains(item)) && SceneUtils.SceneGroups.TryGetValue(customScene2.Group, out var value7) && value7.HasMapZone && !CollectableItemManager.IsInHiddenMode())
						{
							customScene2.Gms.spriteRenderer.color = value7.MapColour;
							if (instance.hasQuill && !pinsOnly)
							{
								customScene2.Gms.initialColor = value7.MapColour;
								customScene2.Gms.hasBeenSet = false;
								customScene2.Gms.SetMapped();
							}
						}
						else
						{
							customScene2.Gms.SetNotMapped();
						}
					}
				}
			});
			typeof(GameMap).Hook("HasMapForScene", (<>F{00000400}<HasMapForScene, GameMap, string, bool, bool>)delegate(HasMapForScene orig, GameMap self, string sceneName, out bool hasSceneSprite)
			{
				if (SceneUtils.CustomScenes.TryGetValue(sceneName, out var value5) && SceneUtils.SceneGroups.TryGetValue(value5.Group, out var value6))
				{
					hasSceneSprite = value6.HasMapZone && Object.op_Implicit((Object)(object)value5.Gms) && Object.op_Implicit((Object)(object)value5.Gms.BoundsSprite);
					return value6.HasMapZone;
				}
				return orig(self, sceneName, out hasSceneSprite);
			});
			typeof(InventoryItemWideMapZone).Hook("GetNextSelectable", (Func<Func<InventoryItemWideMapZone, SelectionDirection, InventoryItemSelectable>, InventoryItemWideMapZone, SelectionDirection, InventoryItemSelectable>)delegate(Func<InventoryItemWideMapZone, SelectionDirection, InventoryItemSelectable> orig, InventoryItemWideMapZone self, SelectionDirection dir)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Expected O, but got Unknown
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				string[] splitName = ((Object)self).name.Split("_");
				int num4 = splitName.Length;
				int num5 = num4;
				if (num5 <= 4)
				{
					if (num5 > 2)
					{
						SceneGroup sceneGroup = SceneUtils.SceneGroups.Values.FirstOrDefault((SceneGroup cm) => cm.OverwriteEnter[dir].Contains(splitName[2]));
						if (sceneGroup != null)
						{
							return (InventoryItemSelectable)(object)sceneGroup.MapZone;
						}
					}
				}
				else
				{
					SceneGroup sceneGroup2 = SceneUtils.SceneGroups.Values.FirstOrDefault((SceneGroup cm) => cm.OverwriteEnter[dir].Contains(splitName[4]));
					if (sceneGroup2 != null)
					{
						return (InventoryItemSelectable)(object)sceneGroup2.MapZone;
					}
				}
				CustomMapZone component3 = ((Component)self).GetComponent<CustomMapZone>();
				if (Object.op_Implicit((Object)(object)component3))
				{
					foreach (Transform item2 in ((Component)_wideMap).transform)
					{
						Transform val5 = item2;
						string[] array = ((Object)val5).name.Split("_");
						int num6 = array.Length;
						int num7 = num6;
						if (num7 <= 4)
						{
							if (num7 > 2 && component3.SceneGroup.OverwriteExit[dir].Contains(array[2]))
							{
								return (InventoryItemSelectable)(object)((Component)val5).GetComponent<InventoryItemWideMapZone>();
							}
						}
						else if (component3.SceneGroup.OverwriteExit[dir].Contains(array[4]))
						{
							return (InventoryItemSelectable)(object)((Component)val5).GetComponent<InventoryItemWideMapZone>();
						}
					}
					InventoryItemSelectable selectableFromAutoNavGroup = ((InventoryItemSelectableDirectional)self).GetSelectableFromAutoNavGroup<InventoryItemSelectable>(dir, (Func<InventoryItemSelectable, bool>)null);
					return (selectableFromAutoNavGroup is InventoryItemWideMapZone) ? selectableFromAutoNavGroup : null;
				}
				return orig(self, dir);
			}, typeof(SelectionDirection));
			typeof(InventoryWideMap).Hook("UpdatePositions", (Action<Action<InventoryWideMap>, InventoryWideMap>)delegate(Action<InventoryWideMap> orig, InventoryWideMap self)
			{
				if ((Object)(object)self != (Object)(object)_wideMap)
				{
					ArchitectPlugin.Logger.LogInfo((object)"Setting up WideMap");
					_wideMap = self;
					foreach (SceneGroup value8 in SceneUtils.SceneGroups.Values)
					{
						value8.RegisterMap();
					}
					SceneUtils.AdjustMapScale(_wideMap);
				}
				orig(self);
			});
			Vector2 zoomPos = default(Vector2);
			bool customZoom = false;
			typeof(InventoryItemWideMapZone).Hook("Submit", (Func<Func<InventoryItemWideMapZone, bool>, InventoryItemWideMapZone, bool>)delegate(Func<InventoryItemWideMapZone, bool> orig, InventoryItemWideMapZone self)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				CustomMapZone component2 = ((Component)self).GetComponent<CustomMapZone>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					zoomPos = component2.SceneGroup.ZoomPos;
					customZoom = true;
				}
				else
				{
					customZoom = false;
				}
				return orig(self);
			});
			typeof(InventoryMapManager).Hook("ZoomIn", (Action<Action<InventoryMapManager, MapZone, bool>, InventoryMapManager, MapZone, bool>)delegate(Action<InventoryMapManager, MapZone, bool> orig, InventoryMapManager self, MapZone zone, bool animate)
			{
				//IL_0001: 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_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				if ((int)zone == 0 && zoomPos == default(Vector2) && SceneUtils.CustomScenes.TryGetValue(GameManager.instance.sceneName, out var value3) && SceneUtils.SceneGroups.TryGetValue(value3.Group, out var value4))
				{
					zoomPos = value4.ZoomPos;
					customZoom = true;
				}
				orig(self, zone, animate);
			});
			typeof(GameMap).Hook("GetZoomPosition", (Func<Func<GameMap, MapZone, Vector2>, GameMap, MapZone, Vector2>)((Func<GameMap, MapZone, Vector2> orig, GameMap self, MapZone zone) => customZoom ? (zoomPos * -1.15f) : orig(self, zone)));
			typeof(GameMap).Hook("GetClosestWideMapZone", (Func<Func<GameMap, IEnumerable<InventoryItemWideMapZone>, InventoryItemWideMapZone>, GameMap, IEnumerable<InventoryItemWideMapZone>, InventoryItemWideMapZone>)delegate(Func<GameMap, IEnumerable<InventoryItemWideMapZone>, InventoryItemWideMapZone> orig, GameMap self, IEnumerable<InventoryItemWideMapZone> wideMapPieces)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: 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)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				InventoryItemWideMapZone val = orig(self, wideMapPieces);
				float num = float.MaxValue;
				Vector3 val2 = -((Component)self).transform.localPosition;
				if (Object.op_Implicit((Object)(object)val))
				{
					ZoneInfo val3 = self.mapZoneInfo[val.zoomToZone];
					ParentInfo[] parents = val3.Parents;
					foreach (ParentInfo val4 in parents)
					{
						if (Object.op_Implicit((Object)(object)val4.Parent))
						{
							for (int j = 0; j < val4.Parent.transform.childCount; j++)
							{
								Transform child = val4.Parent.transform.GetChild(j);
								Vector2 localScenePos = GameMap.GetLocalScenePos(child);
								float num2 = Vector2.Distance(Vector2.op_Implicit(val2), localScenePos);
								if (num2 <= num)
								{
									num = num2;
								}
							}
						}
					}
				}
				foreach (SceneGroup value9 in SceneUtils.SceneGroups.Values)
				{
					if (value9.HasMap())
					{
						float num3 = Vector2.Distance(Vector2.op_Implicit(val2), value9.ZoomPos) - value9.Radius;
						if (num3 < num)
						{
							num = num3;
							val = value9.MapZone;
						}
					}
				}
				return val;
			});
			typeof(GameMap).Hook("EnableUnlockedAreas", (Action<Action<GameMap, MapZone?>, GameMap, MapZone?>)delegate(Action<GameMap, MapZone?> orig, GameMap self, MapZone? setCurrent)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Invalid comparison between Unknown and I4
				if (setCurrent.HasValue)
				{
					if ((int)setCurrent.Value == 0 && SceneUtils.CustomScenes.TryGetValue(GameManager.instance.sceneName, out var value) && SceneUtils.SceneGroups.TryGetValue(value.Group, out var value2) && value2.HasMap())
					{
						value2.FocusMapObject.SetActive(true);
					}
				}
				else
				{
					foreach (SceneGroup item3 in SceneUtils.SceneGroups.Values.Where((SceneGroup group) => group.HasMap()))
					{
						item3.FocusMapObject.SetActive(true);
					}
				}
				orig(self, setCurrent);
			});
			new Hook((MethodBase)typeof(InventoryItemWideMapZone).GetProperty("IsUnlocked").GetGetMethod(), (Delegate)(Func<Func<InventoryItemWideMapZone, bool>, InventoryItemWideMapZone, bool>)delegate(Func<InventoryItemWideMapZone, bool> orig, InventoryItemWideMapZone self)
			{
				CustomMapZone component = ((Component)self).GetComponent<CustomMapZone>();
				return Object.op_Implicit((Object)(object)component) ? component.SceneGroup.HasMap() : orig(self);
			});
		}

		public bool HasMap()
		{
			if (!HasMapZone)
			{
				return false;
			}
			return Utility.IsNullOrWhiteSpace(Variable) || ArchitectData.Instance.BoolVariables.GetValueOrDefault(Variable, defaultValue: false);
		}

		public void RegisterMap()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			if (!HasMapZone)
			{
				return;
			}
			_mapObject = Object.Instantiate<GameObject>(((Component)((Component)_wideMap).transform.Find("Wide_map__0007_Bonetown")).gameObject, ((Component)_wideMap).transform, true);
			((Object)_mapObject).name = "Wide_map_" + Id;
			MapZone = _mapObject.GetComponent<InventoryItemWideMapZone>();
			((InventoryItemSelectableDirectional)MapZone).Selectables = (InventoryItemSelectable[])(object)new InventoryItemSelectable[4];
			MapZone.zoomToZone = (MapZone)0;
			CustomMapZone customMapZone = _mapObject.AddComponent<CustomMapZone>();
			customMapZone.SceneGroup = this;
			customMapZone.OnEnable();
			Transform val = _mapObject.transform.Find("Area Name");
			((Component)val).GetComponent<SetTextMeshProGameText>().text = (LocalStr)GroupName;
			Extensions.SetPositionX(val, Extensions.GetPositionX(val) + LabelPos.x);
			Extensions.SetPositionY(val, Extensions.GetPositionY(val) + LabelPos.y);
			_mapObject.transform.localPosition = Vector2.op_Implicit(MapPos);
			_mapObject.GetComponent<SpriteRenderer>().sprite = MapSprite;
			GameMap gameMap = GameManager.instance.gameMap;
			GameObject val2 = new GameObject(Id)
			{
				layer = UILayer
			};
			val2.transform.parent = ((Component)gameMap).transform;
			val2.transform.localPosition = Vector2.op_Implicit(ZoomPos);
			val2.transform.localScale = Vector3.one;
			FocusMapObject = val2;
			GameObject val3 = Object.Instantiate<GameObject>(_areaTextPrefab, FocusMapObject.transform);
			val3.SetActive(true);
			((Object)val3).name = "Area Name";
			val3.transform.localPosition = Vector2.op_Implicit(AreaNamePos);
			val3.GetComponent<SetTextMeshProGameText>().text = (LocalStr)GroupName;
			((Graphic)val3.GetComponent<TextMeshPro>()).color = MapColour;
			foreach (CustomScene item in SceneUtils.CustomScenes.Values.Where((CustomScene s) => s.Group == Id))
			{
				item.TrySetupMap();
			}
			FocusMapObject.SetActive(false);
			_mapObject.SetActive(true);
			GameManager.instance.gameMap.CalculateMapScrollBounds();
			SceneUtils.AdjustMapScale(_wideMap);
		}

		public override void Register()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			Background = new AreaBackground
			{
				BackgroundImage = ArchitectPlugin.BlankSprite,
				NameOverride = (LocalStr)GroupName,
				Act3OverlayOptOut = DisableAct3Bg
			};
			SceneUtils.SceneGroups.Add(Id, this);
			base.Register();
			RefreshMapSprite();
			if (Object.op_Implicit((Object)(object)_wideMap))
			{
				RegisterMap();
			}
		}

		public void RefreshMapSprite()
		{
			if (Utility.IsNullOrWhiteSpace(MapUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(MapUrl, MPoint, MPpu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					MapSprite = sprites[0];
					SceneUtils.AdjustMapScale(_wideMap);
					if (Object.op_Implicit((Object)(object)_mapObject))
					{
						_mapObject.GetComponent<SpriteRenderer>().sprite = MapSprite;
					}
				}
			});
		}

		protected override void OnReadySprite()
		{
			Background.BackgroundImage = Sprite;
		}

		public override void Unregister()
		{
			SceneUtils.SceneGroups.Remove(Id);
			if (Object.op_Implicit((Object)(object)_mapObject))
			{
				if (((MonoBehaviour)MapZone).didAwake)
				{
					((InventoryPaneBase)MapZone.pane).OnPaneStart -= MapZone.EvaluateUnlocked;
				}
				_wideMap.selectables = null;
				Object.Destroy((Object)(object)_mapObject);
			}
			if (Object.op_Implicit((Object)(object)FocusMapObject))
			{
				Object.Destroy((Object)(object)FocusMapObject);
			}
			SceneUtils.AdjustMapScale(_wideMap);
		}
	}
	public abstract class SpriteItem : WorkshopItem
	{
		public string IconUrl = string.Empty;

		public bool Point;

		public float Ppu = 100f;

		protected Sprite Sprite;

		public override (string, string)[] FilesToDownload => new(string, string)[1] { (IconUrl, "png") };

		public override void Register()
		{
			RefreshSprite();
		}

		public void RefreshSprite()
		{
			if (Utility.IsNullOrWhiteSpace(IconUrl))
			{
				return;
			}
			CustomAssetManager.DoLoadSprite(IconUrl, Point, Ppu, 1, 1, delegate(Sprite[] sprites)
			{
				if (!Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)sprites))
				{
					Sprite = sprites[0];
					OnReadySprite();
					WorkshopUI.RefreshIcon(this);
				}
			});
		}

		public override Sprite GetIcon()
		{
			return Sprite;
		}

		protected virtual void OnReadySprite()
		{
		}
	}
	public class StatusEffect : WorkshopItem
	{
		private static readonly Sprite Sprite = ResourceUtils.LoadSpriteResource("effect", (FilterMode)0);

		public override void Register()
		{
		}

		public override void Unregister()
		{
		}

		public override Sprite GetIcon()
		{
			return Sprite;
		}
	}
	public abstract class WorkshopItem
	{
		public string Id;

		public string Type;

		public List<Architect.Workshop.Types.ConfigType>[] Config;

		public Dictionary<string, Architect.Workshop.Types.ConfigValue> CurrentConfig;

		public virtual (string, string)[] FilesToDownload => null;

		public abstract void Register();

		public abstract void Unregister();

		public abstract Sprite GetIcon();

		public virtual int GetPriority()
		{
			return 0;
		}
	}
}
namespace Architect.Workshop.Config
{
	public static class ConfigGroup
	{
		public static readonly List<Architect.Workshop.Types.ConfigType> SpriteItem = new List<Architect.Workshop.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SpriteItem>("Icon URL", "png_url", delegate(SpriteItem item, Architect.Workshop.Types.StringConfigValue<SpriteItem> value)
			{
				item.IconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<SpriteItem>("Anti Aliasing", "png_antialias", delegate(SpriteItem item, Architect.Workshop.Types.BoolConfigValue<SpriteItem> value)
			{
				item.Point = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SpriteItem>("Pixels Per Unit", "png_ppu", delegate(SpriteItem item, Architect.Workshop.Types.FloatConfigValue<SpriteItem> value)
			{
				item.Ppu = value.GetValue();
			}).WithDefaultValue(100f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> JournalEntry = new List<Architect.Workshop.Types.ConfigType>(9)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomJournalEntry>("Enemy Name", "journal_display_name", delegate(CustomJournalEntry item, Architect.Workshop.Types.StringConfigValue<CustomJournalEntry> value)
			{
				item.ItemName = value.GetValue();
			}).WithDefaultValue("Sample Name")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomJournalEntry>("Description", "journal_desc", delegate(CustomJournalEntry item, Architect.Workshop.Types.StringConfigValue<CustomJournalEntry> value)
			{
				item.ItemDesc = value.GetValue();
			}).WithDefaultValue("Sample Description")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomJournalEntry>("Hunter's Notes", "journal_hdesc", delegate(CustomJournalEntry item, Architect.Workshop.Types.StringConfigValue<CustomJournalEntry> value)
			{
				item.ItemHDesc = value.GetValue();
			}).WithDefaultValue("Sample Hunter's Notes")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomJournalEntry>("Required Kills", "journal_kills", delegate(CustomJournalEntry item, Architect.Workshop.Types.IntConfigValue<CustomJournalEntry> value)
			{
				item.KillsRequired = value.GetValue();
			}).WithDefaultValue(1)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomJournalEntry>("Requirement", "journal_requirements", delegate(CustomJournalEntry item, Architect.Workshop.Types.ChoiceConfigValue<CustomJournalEntry> value)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				item.Required = (RequiredTypes)value.GetValue();
			}).WithOptions("None", "Required", "Steel Soul").WithDefaultValue(1)),
			(NoteConfigType)"A vanilla entry (list can be found in the guide)",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomJournalEntry>("Add Before", "journal_before", delegate(CustomJournalEntry item, Architect.Workshop.Types.StringConfigValue<CustomJournalEntry> value)
			{
				item.InsertBefore = value.GetValue();
			})),
			(NoteConfigType)"Entries with higher priorities are loaded earlier",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomJournalEntry>("Load Priority", "journal_priority", delegate(CustomJournalEntry item, Architect.Workshop.Types.IntConfigValue<CustomJournalEntry> value)
			{
				item.Priority = -value.GetValue();
			}).WithDefaultValue(0))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> MateriumEntry = new List<Architect.Workshop.Types.ConfigType>(4)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomMateriumEntry>("Item Name", "materium_display_name", delegate(CustomMateriumEntry item, Architect.Workshop.Types.StringConfigValue<CustomMateriumEntry> value)
			{
				item.ItemName = value.GetValue();
			}).WithDefaultValue("Sample Name")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomMateriumEntry>("Description", "materium_desc", delegate(CustomMateriumEntry item, Architect.Workshop.Types.StringConfigValue<CustomMateriumEntry> value)
			{
				item.Desc = value.GetValue();
			}).WithDefaultValue("Sample Description")),
			(NoteConfigType)"A vanilla entry (list can be found in the guide)",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomMateriumEntry>("Add Before", "materium_before", delegate(CustomMateriumEntry item, Architect.Workshop.Types.StringConfigValue<CustomMateriumEntry> value)
			{
				item.InsertBefore = value.GetValue();
			}))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> Cue = new List<Architect.Workshop.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCue>("WAV URL", "music_cue_wav_url", delegate(CustomCue item, Architect.Workshop.Types.StringConfigValue<CustomCue> value)
			{
				item.WavUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomCue>("Mode", "music_cue_mode", delegate(CustomCue item, Architect.Workshop.Types.ChoiceConfigValue<CustomCue> value)
			{
				item.IsAtmos = value.GetValue() == 1;
			}).WithOptions("Music", "Atmos").WithDefaultValue(0))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> JournalEntrySprites = new List<Architect.Workshop.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomJournalEntry>("Enemy Image URL", "png_journal_url", delegate(CustomJournalEntry item, Architect.Workshop.Types.StringConfigValue<CustomJournalEntry> value)
			{
				item.LIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomJournalEntry>("Anti Aliasing", "png_journal_antialias", delegate(CustomJournalEntry item, Architect.Workshop.Types.BoolConfigValue<CustomJournalEntry> value)
			{
				item.LPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomJournalEntry>("Pixels Per Unit", "png_journal_ppu", delegate(CustomJournalEntry item, Architect.Workshop.Types.FloatConfigValue<CustomJournalEntry> value)
			{
				item.LPpu = value.GetValue();
			}).WithDefaultValue(100f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> MapIcon = new List<Architect.Workshop.Types.ConfigType>(6)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomMapIcon>("Custom Scene ID", "map_icon_scene", delegate(CustomMapIcon item, Architect.Workshop.Types.StringConfigValue<CustomMapIcon> value)
			{
				item.Scene = value.GetValue();
			})),
			(NoteConfigType)"The icon is unlocked when this global variable is true (if set)",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomMapIcon>("Required Variable", "map_icon_reqvar", delegate(CustomMapIcon item, Architect.Workshop.Types.StringConfigValue<CustomMapIcon> value)
			{
				item.ReqVar = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomMapIcon>("Visibility Mode", "map_icon_visual_mode", delegate(CustomMapIcon item, Architect.Workshop.Types.ChoiceConfigValue<CustomMapIcon> value)
			{
				item.Mode = value.GetValue();
			}).WithOptions("Both", "Quick Map", "Inventory").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Offset X", "map_icon_x", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.Pos.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Offset Y", "map_icon_y", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.Pos.y = value.GetValue();
			}).WithDefaultValue(0f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> MapIconLabel = new List<Architect.Workshop.Types.ConfigType>(7)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomMapIcon>("Text", "map_icon_text", delegate(CustomMapIcon item, Architect.Workshop.Types.StringConfigValue<CustomMapIcon> value)
			{
				item.Text = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Font Size", "map_icon_font_size", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.FontSize = value.GetValue();
			}).WithDefaultValue(6.2f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Text Offset X", "map_icon_text_x", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.Offset.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Text Offset Y", "map_icon_text_y", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.Offset.y = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Text Colour R", "map_icon_text_r", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.Colour.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Text Colour G", "map_icon_text_g", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.Colour.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomMapIcon>("Text Colour B", "map_icon_text_b", delegate(CustomMapIcon item, Architect.Workshop.Types.FloatConfigValue<CustomMapIcon> value)
			{
				item.Colour.b = value.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> UsableItem = new List<Architect.Workshop.Types.ConfigType>(12)
		{
			(NoteConfigType)"Only apply to Usable items",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomItem>("Use Action", "item_consume_desc", delegate(CustomItem item, Architect.Workshop.Types.StringConfigValue<CustomItem> value)
			{
				item.UseType = value.GetValue();
			}).WithDefaultValue("Break")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomItem>("Consume on Use", "item_consume_use", delegate(CustomItem item, Architect.Workshop.Types.BoolConfigValue<CustomItem> value)
			{
				item.Consume = value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomItem>("Use Event", "item_onconsume", delegate(CustomItem item, Architect.Workshop.Types.StringConfigValue<CustomItem> value)
			{
				item.UseEvent = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomItem>("Using Audio URL", "wav_url1", delegate(CustomItem item, Architect.Workshop.Types.StringConfigValue<CustomItem> value)
			{
				item.WavURL1 = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Volume", "wav_volume1", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.Volume1 = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Min Pitch", "wav_min_pitch1", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.MinPitch1 = value.GetValue();
			}).WithDefaultValue(0.8f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Max Pitch", "wav_max_pitch1", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.MaxPitch1 = value.GetValue();
			}).WithDefaultValue(1.2f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomItem>("Used Audio URL", "wav_url2", delegate(CustomItem item, Architect.Workshop.Types.StringConfigValue<CustomItem> value)
			{
				item.WavURL2 = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Volume", "wav_volume2", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.Volume2 = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Min Pitch", "wav_min_pitch2", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.MinPitch2 = value.GetValue();
			}).WithDefaultValue(0.8f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Max Pitch", "wav_max_pitch2", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.MaxPitch2 = value.GetValue();
			}).WithDefaultValue(1.2f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> CourierItem = new List<Architect.Workshop.Types.ConfigType>(11)
		{
			(NoteConfigType)"Only apply to Courier items",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomItem>("Effects", "courier_item_effect", delegate(CustomItem item, Architect.Workshop.Types.ChoiceConfigValue<CustomItem> value)
			{
				item.CourierEffects = value.GetValue();
			}).WithOptions("None", "Swag", "Liquid", "Meat").WithDefaultValue(1)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Ring R", "courier_item_r", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.BarColour.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Ring G", "courier_item_g", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.BarColour.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomItem>("Ring B", "courier_item_b", delegate(CustomItem item, Architect.Workshop.Types.FloatConfigValue<CustomItem> value)
			{
				item.BarColour.b = value.GetValue();
			}).WithDefaultValue(1f)),
			(NoteConfigType)"The time in seconds for the item to break",
			(NoteConfigType)"If set to 0 the item will not break over time",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomItem>("Time to Break", "courier_item_time", delegate(CustomItem item, Architect.Workshop.Types.IntConfigValue<CustomItem> value)
			{
				item.Time = value.GetValue();
			}).WithDefaultValue(0)),
			(NoteConfigType)"The number of rosaries to show up as a reward when used alone in a quest",
			(NoteConfigType)"Setting this to 0 will make the quest appear as a normal quest",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomItem>("Reward Count", "courier_reward_num", delegate(CustomItem item, Architect.Workshop.Types.IntConfigValue<CustomItem> value)
			{
				item.RewardCost = value.GetValue();
			}).WithDefaultValue(0))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> CustomItem = new List<Architect.Workshop.Types.ConfigType>(6)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomItem>("Item Name", "item_display_name", delegate(CustomItem item, Architect.Workshop.Types.StringConfigValue<CustomItem> value)
			{
				item.ItemName = value.GetValue();
			}).WithDefaultValue("Sample Name")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomItem>("Description", "item_desc", delegate(CustomItem item, Architect.Workshop.Types.StringConfigValue<CustomItem> value)
			{
				item.ItemDesc = value.GetValue().Replace("<br>", "\n");
			}).WithDefaultValue("Sample Description")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomItem>("Use Description", "item_udesc", delegate(CustomItem item, Architect.Workshop.Types.StringConfigValue<CustomItem> value)
			{
				item.UseDesc = value.GetValue().Replace("<br>", "\n");
			}).WithDefaultValue("Sample Use Description")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomItem>("Hide in Inventory", "item_hide_inventory", delegate(CustomItem item, Architect.Workshop.Types.BoolConfigValue<CustomItem> value)
			{
				item.Hidden = value.GetValue();
			}).WithDefaultValue(value: false)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomItem>("Item Type", "item_consume", delegate(CustomItem item, Architect.Workshop.Types.ChoiceConfigValue<CustomItem> value)
			{
				item.ItemType = Enum.Parse<CustomItem.CustomItemType>(value.GetStringValue());
			}).WithOptions("Normal", "Usable", "Memento", "Courier").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomItem>("Max Amount", "item_max", delegate(CustomItem item, Architect.Workshop.Types.IntConfigValue<CustomItem> value)
			{
				item.MaxAmount = value.GetValue();
			}))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> CustomTool = new List<Architect.Workshop.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomTool>("Tool Name", "tool_name", delegate(CustomTool item, Architect.Workshop.Types.StringConfigValue<CustomTool> value)
			{
				item.ItemName = value.GetValue();
			}).WithDefaultValue("Sample Name")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomTool>("Description", "tool_desc", delegate(CustomTool item, Architect.Workshop.Types.StringConfigValue<CustomTool> value)
			{
				item.ItemDesc = value.GetValue().Replace("<br>", "\n");
			}).WithDefaultValue("Sample Description")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomTool>("Type", "tool_type", delegate(CustomTool item, Architect.Workshop.Types.ChoiceConfigValue<CustomTool> value)
			{
				//IL_002a: 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)
				item.IsLiquid = value.GetValue() == 4;
				if (item.IsLiquid)
				{
					item.ItemType = (ToolItemType)0;
				}
				else
				{
					item.ItemType = (ToolItemType)value.GetValue();
				}
			}).WithDefaultValue(0).WithOptions("Red", "Blue", "Yellow", "Skill"))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> Keybind = new List<Architect.Workshop.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomKeybind>("Name", "keybind_name", delegate(CustomKeybind item, Architect.Workshop.Types.StringConfigValue<CustomKeybind> value)
			{
				item.Name = value.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomKeybind>("Default Key", "keybind_default", delegate(CustomKeybind item, Architect.Workshop.Types.StringConfigValue<CustomKeybind> value)
			{
				//IL_0013: 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)
				if (Enum.TryParse<KeyCode>(value.GetValue(), out KeyCode result3))
				{
					item.Default = result3;
				}
			}).WithDefaultValue("None"))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> Scene = new List<Architect.Workshop.Types.ConfigType>(4)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomScene>("Group ID", "scene_group", delegate(CustomScene item, Architect.Workshop.Types.StringConfigValue<CustomScene> value)
			{
				item.Group = value.GetValue();
			}).WithDefaultValue("None")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomScene>("Scene Width", "scene_tilemap_width", delegate(CustomScene item, Architect.Workshop.Types.IntConfigValue<CustomScene> value)
			{
				item.TilemapWidth = value.GetValue();
			}).WithDefaultValue(500)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomScene>("Scene Height", "scene_tilemap_height", delegate(CustomScene item, Architect.Workshop.Types.IntConfigValue<CustomScene> value)
			{
				item.TilemapHeight = value.GetValue();
			}).WithDefaultValue(500)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomScene>("Environment Type", "scene_enviro_type", delegate(CustomScene item, Architect.Workshop.Types.ChoiceConfigValue<CustomScene> value)
			{
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				string text = value.GetStringValue();
				string text2 = text;
				string text3 = text2;
				if (!(text3 == "WaterS"))
				{
					if (text3 == "WaterRun")
					{
						text = "RunningWater";
					}
				}
				else
				{
					text = "ShallowWater";
				}
				if (Enum.TryParse<EnvironmentTypes>(text, out EnvironmentTypes result2))
				{
					item.Environment = result2;
				}
			}).WithOptions("Dust", "Grass", "Bone", "WaterS", "Metal", "NoEffect", "Moss", "Sand", "Bell", "WetMetal", "ThinMetal", "Wood", "Silk", "WetWood", "WaterRun", "PeakPuff", "FlowerField").WithDefaultValue(0))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneMap = new List<Architect.Workshop.Types.ConfigType>(9)
		{
			(NoteConfigType)"Only applies if the scene's group has a map",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomScene>("Map X Offset", "scene_map_x", delegate(CustomScene item, Architect.Workshop.Types.FloatConfigValue<CustomScene> value)
			{
				item.MapPos.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomScene>("Map Y Offset", "scene_map_y", delegate(CustomScene item, Architect.Workshop.Types.FloatConfigValue<CustomScene> value)
			{
				item.MapPos.y = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SpriteItem>("Full Map URL", "scene_full_map_url", delegate(SpriteItem item, Architect.Workshop.Types.StringConfigValue<SpriteItem> value)
			{
				item.IconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<SpriteItem>("Anti Aliasing", "scene_full_map_antialias", delegate(SpriteItem item, Architect.Workshop.Types.BoolConfigValue<SpriteItem> value)
			{
				item.Point = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SpriteItem>("Pixels Per Unit", "scene_full_map_ppu", delegate(SpriteItem item, Architect.Workshop.Types.FloatConfigValue<SpriteItem> value)
			{
				item.Ppu = value.GetValue();
			}).WithDefaultValue(100f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomScene>("Empty Room URL", "scene_empty_map_url", delegate(CustomScene item, Architect.Workshop.Types.StringConfigValue<CustomScene> value)
			{
				item.EIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomScene>("Anti Aliasing", "scene_empty_map_antialias", delegate(CustomScene item, Architect.Workshop.Types.BoolConfigValue<CustomScene> value)
			{
				item.EPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomScene>("Pixels Per Unit", "scene_empty_map_ppu", delegate(CustomScene item, Architect.Workshop.Types.FloatConfigValue<CustomScene> value)
			{
				item.EPpu = value.GetValue();
			}).WithDefaultValue(100f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneMapColour = new List<Architect.Workshop.Types.ConfigType>(4)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomScene>("Override Colour", "scene_override_col", delegate(CustomScene item, Architect.Workshop.Types.BoolConfigValue<CustomScene> value)
			{
				item.OverrideColour = value.GetValue();
			}).WithDefaultValue(value: false)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomScene>("Colour R", "scene_override_col_r", delegate(CustomScene item, Architect.Workshop.Types.FloatConfigValue<CustomScene> value)
			{
				item.MapColour.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomScene>("Colour G", "scene_override_col_g", delegate(CustomScene item, Architect.Workshop.Types.FloatConfigValue<CustomScene> value)
			{
				item.MapColour.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomScene>("Colour B", "scene_override_col_b", delegate(CustomScene item, Architect.Workshop.Types.FloatConfigValue<CustomScene> value)
			{
				item.MapColour.b = value.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneGroup = new List<Architect.Workshop.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Area Name", "scene_group_name", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
		{
			item.GroupName = value.GetValue();
		})) };

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneGroupIcon = new List<Architect.Workshop.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SpriteItem>("Save Icon URL", "scene_group_url", delegate(SpriteItem item, Architect.Workshop.Types.StringConfigValue<SpriteItem> value)
			{
				item.IconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<SpriteItem>("Anti Aliasing", "scene_group_antialias", delegate(SpriteItem item, Architect.Workshop.Types.BoolConfigValue<SpriteItem> value)
			{
				item.Point = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<SceneGroup>("Hide Void Overlay", "scene_group_no_void", delegate(SceneGroup item, Architect.Workshop.Types.BoolConfigValue<SceneGroup> value)
			{
				item.DisableAct3Bg = value.GetValue();
			}).WithDefaultValue(value: false))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneGroupMap = new List<Architect.Workshop.Types.ConfigType>(9)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<SceneGroup>("Has Map", "scene_group_map", delegate(SceneGroup item, Architect.Workshop.Types.BoolConfigValue<SceneGroup> value)
			{
				item.HasMapZone = value.GetValue();
			}).WithDefaultValue(value: false)),
			(NoteConfigType)"The map is unlocked when this global variable is true (if set)",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Required Variable", "scene_group_map_var", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.Variable = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Map Icon URL", "scene_group_map_url", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.MapUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<SceneGroup>("Anti Aliasing", "scene_group_map_antialias", delegate(SceneGroup item, Architect.Workshop.Types.BoolConfigValue<SceneGroup> value)
			{
				item.MPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Pixels Per Unit", "scene_group_map_ppu", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.MPpu = value.GetValue();
			}).WithDefaultValue(100f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Map Colour R", "scene_group_map_cr", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.MapColour.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Map Colour G", "scene_group_map_cg", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.MapColour.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Map Colour B", "scene_group_map_cb", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.MapColour.b = value.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneGroupMapPos = new List<Architect.Workshop.Types.ConfigType>(10)
		{
			(NoteConfigType)"The position of the map, label and zoomed in map",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Map X", "scene_group_map_px", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.MapPos.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Map Y", "scene_group_map_py", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.MapPos.y = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Title Offset X", "scene_group_map_lx", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.LabelPos.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Title Offset Y", "scene_group_map_ly", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.LabelPos.y = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Zoom X", "scene_group_map_zx", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.ZoomPos.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Zoom Y", "scene_group_map_zy", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.ZoomPos.y = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Area Label X", "scene_group_map_alx", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.AreaNamePos.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Area Label Y", "scene_group_map_aly", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.AreaNamePos.y = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<SceneGroup>("Area Radius", "scene_group_map_radius", delegate(SceneGroup item, Architect.Workshop.Types.FloatConfigValue<SceneGroup> value)
			{
				item.Radius = value.GetValue();
			}).WithDefaultValue(0.2f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneGroupMapDirIn = new List<Architect.Workshop.Types.ConfigType>(5)
		{
			(NoteConfigType)"Make other maps lead to this one",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Enter Below", "scene_group_map_b", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteEnter[1] = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Enter Above", "scene_group_map_a", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteEnter[0] = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Enter Left", "scene_group_map_l", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteEnter[2] = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Enter Right", "scene_group_map_r", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteEnter[3] = value.GetValue();
			}))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> SceneGroupMapDirOut = new List<Architect.Workshop.Types.ConfigType>(5)
		{
			(NoteConfigType)"Make this map lead to others",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Exit Below", "scene_group_map_b2", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteExit[1] = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Exit Above", "scene_group_map_a2", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteExit[0] = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Exit Left", "scene_group_map_l2", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteExit[2] = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SceneGroup>("Exit Right", "scene_group_map_r2", delegate(SceneGroup item, Architect.Workshop.Types.StringConfigValue<SceneGroup> value)
			{
				item.OverwriteExit[3] = value.GetValue();
			}))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> Quest = new List<Architect.Workshop.Types.ConfigType>(8)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Quest Name", "quest_display_name", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.ItemName = value.GetValue();
			}).WithDefaultValue("Sample Name")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Description", "quest_desc", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.ItemDesc = value.GetValue();
			}).WithDefaultValue("Sample Description")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Board Description", "quest_board_desc", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.WallDesc = value.GetValue();
			}).WithDefaultValue("Sample Board Description")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Quest Category", "quest_display_type", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.TypeName = value.GetValue();
			}).WithDefaultValue("Seek")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomQuest>("Quest Type", "quest_type", delegate(CustomQuest item, Architect.Workshop.Types.ChoiceConfigValue<CustomQuest> value)
			{
				item.MainQuest = value.GetValue() == 1;
			}).WithDefaultValue(0).WithOptions("Regular", "Major")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Colour R", "quest_r", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.Color.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Colour G", "quest_g", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.Color.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Colour B", "quest_b", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.Color.b = value.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> QuestItem = new List<Architect.Workshop.Types.ConfigType>(12)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomQuest>("Include Items", "quest_req_items", delegate(CustomQuest item, Architect.Workshop.Types.BoolConfigValue<CustomQuest> value)
			{
				item.HasItem = value.GetValue();
			}).WithDefaultValue(value: false)),
			(NoteConfigType)"Separating IDs with a comma will share the required count across each item type",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Item ID", "quest_item_id", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.ItemId = value.GetValue();
			})),
			(NoteConfigType)"For normal items, this is the required number to complete the quest",
			(NoteConfigType)"For Courier items, this is the number of hit points the item will have",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomQuest>("Item Count", "quest_item_num", delegate(CustomQuest item, Architect.Workshop.Types.IntConfigValue<CustomQuest> value)
			{
				item.ItemCount = value.GetValue();
			}).WithDefaultValue(1)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Collected Desc", "quest_item_desc_done", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.CollectedDesc = value.GetValue();
			}).WithDefaultValue("Sample Collected Description")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomQuest>("List Counter Type", "quest_item_list_icon", delegate(CustomQuest item, Architect.Workshop.Types.ChoiceConfigValue<CustomQuest> value)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				string stringValue2 = value.GetStringValue();
				if (1 == 0)
				{
				}
				ListCounterTypes listCounterType = ((stringValue2 == "Notches") ? ((ListCounterTypes)0) : ((!(stringValue2 == "Bar")) ? ((ListCounterTypes)2) : ((ListCounterTypes)1)));
				if (1 == 0)
				{
				}
				item.ListCounterType = listCounterType;
			}).WithOptions("Notches", "Bar", "None").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomQuest>("Desc Counter Type", "quest_item_desc_icon", delegate(CustomQuest item, Architect.Workshop.Types.ChoiceConfigValue<CustomQuest> value)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				string stringValue = value.GetStringValue();
				if (1 == 0)
				{
				}
				DescCounterTypes descCounterType = (DescCounterTypes)(stringValue switch
				{
					"Icon" => 0, 
					"Number" => 1, 
					"Bar" => 2, 
					_ => 3, 
				});
				if (1 == 0)
				{
				}
				item.DescCounterType = descCounterType;
			}).WithOptions("Icon", "Number", "Bar", "None").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Counter R", "quest_item_r", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.BarColour.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Counter G", "quest_item_g", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.BarColour.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Counter B", "quest_item_b", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.BarColour.b = value.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> UseToolSprites = new List<Architect.Workshop.Types.ConfigType>(7)
		{
			(NoteConfigType)"Only apply to Red and Skill tools",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomTool>("HUD Icon URL", "png_tool_ui_url", delegate(CustomTool item, Architect.Workshop.Types.StringConfigValue<CustomTool> value)
			{
				item.HIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomTool>("Anti Aliasing", "png_tool_ui_antialias", delegate(CustomTool item, Architect.Workshop.Types.BoolConfigValue<CustomTool> value)
			{
				item.HPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomTool>("Pixels Per Unit", "png_tool_ui_ppu", delegate(CustomTool item, Architect.Workshop.Types.FloatConfigValue<CustomTool> value)
			{
				item.HPpu = value.GetValue();
			}).WithDefaultValue(100f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomTool>("HUD Usable URL", "png_tool_glow_url", delegate(CustomTool item, Architect.Workshop.Types.StringConfigValue<CustomTool> value)
			{
				item.GIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomTool>("Anti Aliasing", "png_tool_glow_antialias", delegate(CustomTool item, Architect.Workshop.Types.BoolConfigValue<CustomTool> value)
			{
				item.GPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomTool>("Pixels Per Unit", "png_tool_glow_ppu", delegate(CustomTool item, Architect.Workshop.Types.FloatConfigValue<CustomTool> value)
			{
				item.GPpu = value.GetValue();
			}).WithDefaultValue(100f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> RedTools = new List<Architect.Workshop.Types.ConfigType>(4)
		{
			(NoteConfigType)"Only apply to Red tools",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomTool>("Max Amount", "tool_red_max", delegate(CustomTool item, Architect.Workshop.Types.IntConfigValue<CustomTool> value)
			{
				item.MaxAmount = value.GetValue();
			}).WithDefaultValue(10)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomTool>("Affected by Pouches", "tool_red_pouch", delegate(CustomTool item, Architect.Workshop.Types.BoolConfigValue<CustomTool> value)
			{
				item.PreventIncrease = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomTool>("Repair Cost", "tool_red_repair_cost", delegate(CustomTool item, Architect.Workshop.Types.IntConfigValue<CustomTool> value)
			{
				item.RepairCost = value.GetValue();
			}).WithDefaultValue(5))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> QuestSprites = new List<Architect.Workshop.Types.ConfigType>(9)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Icon URL", "png_quest_url", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.IconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomQuest>("Anti Aliasing", "png_quest_antialias", delegate(CustomQuest item, Architect.Workshop.Types.BoolConfigValue<CustomQuest> value)
			{
				item.Point = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Pixels Per Unit", "png_quest_ppu", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.Ppu = value.GetValue();
			}).WithDefaultValue(100f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Prompt Icon URL", "png_lquest_url", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.LIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomQuest>("Anti Aliasing", "png_lquest_antialias", delegate(CustomQuest item, Architect.Workshop.Types.BoolConfigValue<CustomQuest> value)
			{
				item.LPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Pixels Per Unit", "png_lquest_ppu", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.LPpu = value.GetValue();
			}).WithDefaultValue(100f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomQuest>("Glow Icon URL", "png_gquest_url", delegate(CustomQuest item, Architect.Workshop.Types.StringConfigValue<CustomQuest> value)
			{
				item.GIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomQuest>("Anti Aliasing", "png_gquest_antialias", delegate(CustomQuest item, Architect.Workshop.Types.BoolConfigValue<CustomQuest> value)
			{
				item.GPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomQuest>("Pixels Per Unit", "png_gquest_ppu", delegate(CustomQuest item, Architect.Workshop.Types.FloatConfigValue<CustomQuest> value)
			{
				item.GPpu = value.GetValue();
			}).WithDefaultValue(100f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> Needle = new List<Architect.Workshop.Types.ConfigType>(8)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomNeedle>("Name", "needle_title", delegate(CustomNeedle item, Architect.Workshop.Types.StringConfigValue<CustomNeedle> value)
			{
				item.Name = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomNeedle>("Description", "needle_desc", delegate(CustomNeedle item, Architect.Workshop.Types.StringConfigValue<CustomNeedle> value)
			{
				item.Desc = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.IntConfigType<CustomNeedle>("Damage", "needle_damage_level", delegate(CustomNeedle item, Architect.Workshop.Types.IntConfigValue<CustomNeedle> value)
			{
				item.Damage = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomNeedle>("Range Multiplier", "needle_damage_range", delegate(CustomNeedle item, Architect.Workshop.Types.FloatConfigValue<CustomNeedle> value)
			{
				item.NeedleRangeMult = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomNeedle>("Colour Mode", "needle_colour_mode", delegate(CustomNeedle item, Architect.Workshop.Types.ChoiceConfigValue<CustomNeedle> value)
			{
				item.NeedleColourActive = value.GetValue();
			}).WithOptions("Off", "PreImbue", "PostImbue").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomNeedle>("Colour R", "needle_colour_r", delegate(CustomNeedle item, Architect.Workshop.Types.FloatConfigValue<CustomNeedle> value)
			{
				item.NeedleColour.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomNeedle>("Colour G", "needle_colour_g", delegate(CustomNeedle item, Architect.Workshop.Types.FloatConfigValue<CustomNeedle> value)
			{
				item.NeedleColour.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomNeedle>("Colour B", "needle_colour_b", delegate(CustomNeedle item, Architect.Workshop.Types.FloatConfigValue<CustomNeedle> value)
			{
				item.NeedleColour.b = value.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> Crest = new List<Architect.Workshop.Types.ConfigType>(6)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCrest>("Unlock Prefix", "crest_name_prefix", delegate(CustomCrest item, Architect.Workshop.Types.StringConfigValue<CustomCrest> value)
			{
				item.NamePrefix = value.GetValue();
			}).WithDefaultValue("Bound the Crest of")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCrest>("Name", "crest_name", delegate(CustomCrest item, Architect.Workshop.Types.StringConfigValue<CustomCrest> value)
			{
				item.Name = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCrest>("Description", "crest_desc", delegate(CustomCrest item, Architect.Workshop.Types.StringConfigValue<CustomCrest> value)
			{
				item.Desc = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCrest>("Equip Desc", "crest_equip_desc", delegate(CustomCrest item, Architect.Workshop.Types.StringConfigValue<CustomCrest> value)
			{
				item.EquipText = value.GetValue();
			}).WithDefaultValue("To change Crest, open the Crest screen of the Menu while resting at a bench.")),
			(NoteConfigType)"Determines the moveset for the crest, does not affect the bind",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomCrest>("Base Movement", "crest_base_movement", delegate(CustomCrest item, Architect.Workshop.Types.ChoiceConfigValue<CustomCrest> value)
			{
				item.Movement = value.GetStringValue();
			}).WithOptions("Hunter", "Reaper", "Wanderer", "Beast", "Witch", "Architect", "Shaman", "Cursed", "Cloakless").WithDefaultValue(0))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> CrestSprites = new List<Architect.Workshop.Types.ConfigType>(6)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCrest>("Silhouette URL", "png_crest_sil_url", delegate(CustomCrest item, Architect.Workshop.Types.StringConfigValue<CustomCrest> value)
			{
				item.HIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomCrest>("Anti Aliasing", "png_crest_sil_antialias", delegate(CustomCrest item, Architect.Workshop.Types.BoolConfigValue<CustomCrest> value)
			{
				item.HPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomCrest>("Pixels Per Unit", "png_crest_sil_ppu", delegate(CustomCrest item, Architect.Workshop.Types.FloatConfigValue<CustomCrest> value)
			{
				item.HPpu = value.GetValue();
			}).WithDefaultValue(100f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCrest>("Glow URL", "png_crest_glow_url", delegate(CustomCrest item, Architect.Workshop.Types.StringConfigValue<CustomCrest> value)
			{
				item.GIconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomCrest>("Anti Aliasing", "png_crest_glow_antialias", delegate(CustomCrest item, Architect.Workshop.Types.BoolConfigValue<CustomCrest> value)
			{
				item.GPoint = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomCrest>("Pixels Per Unit", "png_crest_glow_ppu", delegate(CustomCrest item, Architect.Workshop.Types.FloatConfigValue<CustomCrest> value)
			{
				item.GPpu = value.GetValue();
			}).WithDefaultValue(100f))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> CrestSlot = new List<Architect.Workshop.Types.ConfigType>(7)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomCrest.CrestSlot>("Crest ID", "crest_target_id", delegate(CustomCrest.CrestSlot item, Architect.Workshop.Types.StringConfigValue<CustomCrest.CrestSlot> value)
			{
				item.CrestId = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomCrest.CrestSlot>("Type", "crest_slot_type", delegate(CustomCrest.CrestSlot item, Architect.Workshop.Types.ChoiceConfigValue<CustomCrest.CrestSlot> value)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				item.ToolType = (ToolItemType)value.GetValue();
			}).WithDefaultValue(0).WithOptions("Red", "Blue", "Yellow", "Skill")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomCrest.CrestSlot>("Direction", "crest_slot_dir", delegate(CustomCrest.CrestSlot item, Architect.Workshop.Types.ChoiceConfigValue<CustomCrest.CrestSlot> value)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				item.Binding = (AttackToolBinding)value.GetValue();
			}).WithDefaultValue(0).WithOptions("Neutral", "Up", "Down")),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomCrest.CrestSlot>("X Pos", "crest_slot_x", delegate(CustomCrest.CrestSlot item, Architect.Workshop.Types.FloatConfigValue<CustomCrest.CrestSlot> value)
			{
				item.Pos.x = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.FloatConfigType<CustomCrest.CrestSlot>("Y Pos", "crest_slot_y", delegate(CustomCrest.CrestSlot item, Architect.Workshop.Types.FloatConfigValue<CustomCrest.CrestSlot> value)
			{
				item.Pos.y = value.GetValue();
			}).WithDefaultValue(0f)),
			(NoteConfigType)"At least one slot must be unlocked by default",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<CustomCrest.CrestSlot>("Start Locked", "crest_slot_locked", delegate(CustomCrest.CrestSlot item, Architect.Workshop.Types.BoolConfigValue<CustomCrest.CrestSlot> value)
			{
				item.Lock = value.GetValue();
			}).WithDefaultValue(value: false))
		};

		public static readonly List<Architect.Workshop.Types.ConfigType> Achievement = new List<Architect.Workshop.Types.ConfigType>(7)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomAchievement>("Name", "achievement_name", delegate(CustomAchievement item, Architect.Workshop.Types.StringConfigValue<CustomAchievement> value)
			{
				item.Name = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomAchievement>("Description", "achievement_desc", delegate(CustomAchievement item, Architect.Workshop.Types.StringConfigValue<CustomAchievement> value)
			{
				item.Desc = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.ChoiceConfigType<CustomAchievement>("Type", "achievement_type", delegate(CustomAchievement item, Architect.Workshop.Types.ChoiceConfigValue<CustomAchievement> value)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				if (Enum.TryParse<AchievementType>(value.GetStringValue(), out AchievementType result))
				{
					item.AchievementType = result;
				}
			}).WithOptions("Normal", "Hidden").WithDefaultValue(0)),
			(NoteConfigType)"A vanilla achievement (list can be found in the guide)",
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<CustomAchievement>("Add Before", "achievement_before", delegate(CustomAchievement item, Architect.Workshop.Types.StringConfigValue<CustomAchievement> value)
			{
				item.InsertBefore = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.StringConfigType<SpriteItem>("Icon URL", "achievement_url", delegate(SpriteItem item, Architect.Workshop.Types.StringConfigValue<SpriteItem> value)
			{
				item.IconUrl = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Workshop.Types.BoolConfigType<SpriteItem>("Anti Aliasing", "achievement_antialias", delegate(SpriteItem item, Architect.Workshop.Types.BoolConfigValue<SpriteItem> value)
			{
				item.Point = !value.GetValue();
			}).WithDefaultValue(value: true))
		};
	}
}
namespace Architect.Utils
{
	public static class FsmUtils
	{
		public class CustomFsmAction : FsmStateAction
		{
			public bool EveryFrame;

			private Action _method;

			public CustomFsmAction(Action method)
			{
				_method = method;
				((FsmStateAction)this)..ctor();
			}

			public override void Reset()
			{
				_method = null;
				((FsmStateAction)this).Reset();
			}

			public override void OnEnter()
			{
				_method();
				if (!EveryFrame)
				{
					((FsmStateAction)this).Finish();
				}
			}

			public override void OnUpdate()
			{
				if (EveryFrame)
				{
					_method();
				}
			}
		}

		public static void AddState(this PlayMakerFSM fsm, string state)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			FsmState[] states = fsm.fsm.States;
			FsmState[] array = (FsmState[])(object)new FsmState[states.Length + 1];
			for (int i = 0; i < states.Length; i++)
			{
				array[i] = states[i];
			}
			FsmState val = new FsmState(fsm.fsm)
			{
				Name = state
			};
			array[states.Length] = val;
			fsm.fsm.States = array;
		}

		public static FsmState GetState(this PlayMakerFSM fsm, string state)
		{
			return fsm.Fsm.GetState(state);
		}

		public static void DisableAction(this FsmState state, int index)
		{
			state.Actions[index].Enabled = false;
		}

		public static void AddAction(this FsmState state, Action action, int index = -1, bool everyFrame = false)
		{
			CustomFsmAction customAction = new CustomFsmAction(action)
			{
				EveryFrame = everyFrame
			};
			state.AddAction((FsmStateAction)(object)customAction, index);
		}

		public static void AddAction(this FsmState state, FsmStateAction customAction, int index = -1)
		{
			FsmStateAction[] actions = state.Actions;
			if (index == -1)
			{
				index = actions.Length;
			}
			FsmStateAction[] array = (FsmStateAction[])(object)new FsmStateAction[actions.Length + 1];
			int num = 0;
			int num2 = 0;
			while (num < array.Length)
			{
				if (num == index)
				{
					array[num] = customAction;
					num++;
				}
				if (num2 < actions.Length)
				{
					array[num] = actions[num2];
				}
				num++;
				num2++;
			}
			state.Actions = array;
			customAction.Init(state);
		}
	}
	public static class HookUtils
	{
		public static Action<HeroController> OnHeroUpdate;

		public static Action<HeroController> OnHeroAwake;

		public static Action<PlayMakerFSM> OnFsmAwake;

		public static void Init()
		{
			typeof(PlayMakerFSM).Hook("Awake", (Action<Action<PlayMakerFSM>, PlayMakerFSM>)delegate(Action<PlayMakerFSM> orig, PlayMakerFSM self)
			{
				orig(self);
				OnFsmAwake?.Invoke(self);
			});
			typeof(HeroController).Hook("Update", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				OnHeroUpdate?.Invoke(self);
			});
			typeof(HeroController).Hook("Awake", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				OnHeroAwake?.Invoke(self);
			});
		}

		public static void Hook(this Type type, string name, Delegate target, params Type[] types)
		{
			//IL_002c: 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)
			if (Extensions.IsNullOrEmpty<Type>((ICollection<Type>)types))
			{
				new Hook((MethodBase)type.GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), target);
			}
			else
			{
				new Hook((MethodBase)type.GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null), target);
			}
		}
	}
	public static class MiscUtils
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass0_0
		{
			public HeroController hero;

			public Predicate<HeroController> condition;

			internal bool <FreeControl>b__0()
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return !hero.controlReqlinquished && (int)HeroController.instance.transitionState == 0 && (condition == null || condition(hero));
			}
		}

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

			private object <>2__current;

			public HeroController hero;

			public Predicate<HeroController> condition;

			private <>c__DisplayClass0_0 <>8__1;

			private PlayMakerFSM <fsm>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<fsm>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass0_0();
					<>8__1.hero = hero;
					<>8__1.condition = condition;
					<fsm>5__2 = <>8__1.hero.sprintFSM;
					if (<fsm>5__2.ActiveStateName.Contains("Sprint"))
					{
						<fsm>5__2.SendEvent("SKID END");
					}
					<>8__1.hero.umbrellaFSM.SendEvent("END");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => !<>8__1.hero.controlReqlinquished && (int)HeroController.instance.transitionState == 0 && (<>8__1.condition == null || <>8__1.condition(<>8__1.hero))));
					<>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();
			}
		}

		[IteratorStateMachine(typeof(<FreeControl>d__0))]
		public static IEnumerator FreeControl(this HeroController hero, Predicate<HeroController> condition = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FreeControl>d__0(0)
			{
				hero = hero,
				condition = condition
			};
		}

		[CanBeNull]
		public static SavedItem GetSavedItem(string name)
		{
			if (((NamedScriptableObjectList<CollectableItem>)(object)ManagerSingleton<CollectableItemManager>.Instance.masterList).dictionary.TryGetValue(name, out var value))
			{
				return (SavedItem)(object)value;
			}
			if (((NamedScriptableObjectList<CollectableRelic>)(object)ManagerSingleton<CollectableRelicManager>.Instance.masterList).dictionary.TryGetValue(name, out var value2))
			{
				return (SavedItem)(object)value2;
			}
			if (((NamedScriptableObjectList<MateriumItem>)(object)ManagerSingleton<MateriumItemManager>.Instance.masterList).dictionary.TryGetValue(name, out var value3))
			{
				return (SavedItem)(object)value3;
			}
			return (SavedItem)(object)((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).dictionary.GetValueOrDefault(name);
		}

		public static int FirstPosMin<T>(this IEnumerable<T> enumerable, Func<T, float> rule, Func<T, float> backupRule)
		{
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			int result = -1;
			int num3 = -1;
			foreach (T item in enumerable)
			{
				num3++;
				float num4 = rule(item);
				float num5 = backupRule(item);
				if (!(num4 <= 0f) && (num4 < num || (Mathf.Approximately(num4, num) && num5 < num2)))
				{
					num = num4;
					num2 = num5;
					result = num3;
				}
			}
			return result;
		}
	}
	public class LocalStr
	{
		public readonly string Content;

		public LocalStr(string s)
		{
			Content = s;
			base..ctor();
		}

		public static implicit operator LocalisedString(LocalStr s)
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			return new LocalisedString("ArchitectMod", s.Content);
		}

		public static implicit operator string(LocalStr s)
		{
			return s.Content;
		}

		public static implicit operator LocalStr(string s)
		{
			return new LocalStr(s);
		}
	}
	public static class ObjectUtils
	{
		public static T GetOrAddComponent<T>(this GameObject obj) where T : Component
		{
			T component = obj.GetComponent<T>();
			return Object.op_Implicit((Object)(object)component) ? component : obj.AddComponent<T>();
		}

		public static void RemoveComponent<T>(this GameObject obj) where T : Component
		{
			T component = obj.GetComponent<T>();
			if (Object.op_Implicit((Object)(object)component))
			{
				Object.Destroy((Object)(object)component);
			}
		}

		public static T ReplaceComponent<T>(this GameObject obj) where T : Component
		{
			obj.RemoveComponent<T>();
			return obj.AddComponent<T>();
		}

		public static void BroadcastEvent(this GameObject obj, string triggerName)
		{
			EventManager.BroadcastEvent(obj, triggerName);
		}

		public static void RemoveComponentsInChildren<T>(this GameObject obj) where T : Component
		{
			T[] componentsInChildren = obj.GetComponentsInChildren<T>(true);
			T[] array = componentsInChildren;
			foreach (T val in array)
			{
				Object.Destroy((Object)(object)val);
			}
		}

		public static string GetPath(this Transform current)
		{
			if (!Object.op_Implicit((Object)(object)current.parent))
			{
				return ((Object)current).name;
			}
			return current.parent.GetPath() + "/" + ((Object)current).name;
		}

		public static GameObject FindGameObject(string path, int index = 0)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < SceneManager.loadedSceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				GameObject gameObjectFromArray = GetGameObjectFromArray(((Scene)(ref sceneAt)).GetRootGameObjects(), path, index);
				if (Object.op_Implicit((Object)(object)gameObjectFromArray))
				{
					return gameObjectFromArray;
				}
			}
			return null;
		}

		internal static GameObject GetGameObjectFromArray(GameObject[] objects, string objName, int index = 0)
		{
			string text = null;
			int num = objName.IndexOf('/');
			string rootName;
			if (num == -1)
			{
				rootName = objName;
			}
			else
			{
				if (num == 0 || num == objName.Length - 1)
				{
					throw new ArgumentException("Invalid GameObject path");
				}
				rootName = objName.Substring(0, num);
				int num2 = num + 1;
				text = objName.Substring(num2, objName.Length - num2);
			}
			GameObject val = objects.Where((GameObject o) => ((Object)o).name == rootName).ElementAtOrDefault(index);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			if (text != null)
			{
				Transform val2 = val.transform.Find(text);
				return (!Object.op_Implicit((Object)(object)val2)) ? null : ((Component)val2).gameObject;
			}
			return val;
		}

		public static Vector3 RotatePointAroundPivot(this Vector3 point, Vector3 pivot, float angle)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0019: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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)
			Vector3 val = point - pivot;
			val = Quaternion.Euler(0f, 0f, angle) * val;
			point = val + pivot;
			return point;
		}

		public static void DisableChild(this Transform transform, params int[] children)
		{
			((Component)children.Aggregate(transform, (Transform current, int c) => current.GetChild(c))).gameObject.SetActive(false);
		}

		public static void ApplyToAllComponents<T>(this GameObject obj, Action<T> action) where T : Component
		{
			T[] componentsInChildren = obj.GetComponentsInChildren<T>(true);
			foreach (T obj2 in componentsInChildren)
			{
				action(obj2);
			}
		}
	}
	public static class PreviewUtils
	{
		public static Vector3 FixPreview(SpriteRenderer renderer, PlaceableObject type, bool flipped, float rotation, float scale)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (type.Tk2dRotation / 90 % 2 != 0)
			{
				renderer.flipY = flipped != type.FlipX;
				renderer.flipX = type.LossyScale.x < 0f;
			}
			else
			{
				renderer.flipX = flipped != type.FlipX;
				renderer.flipY = type.LossyScale.y < 0f;
			}
			Vector3 childOffset = type.ChildOffset;
			childOffset.x /= type.LossyScale.x;
			childOffset.y /= type.LossyScale.y;
			Vector3 val = type.Offset + childOffset;
			val.x *= type.ParentScale.x;
			val.y *= type.ParentScale.y;
			if (flipped)
			{
				val.x = 0f - val.x;
			}
			return Quaternion.Euler(0f, 0f, rotation) * (val * scale);
		}

		public static Sprite ConvertFrom2DToolkit(tk2dSpriteDefinition def, float ppu)
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			Texture mainTexture = def.material.mainTexture;
			Texture2D val = (Texture2D)(object)((mainTexture is Texture2D) ? mainTexture : null);
			if (val == null)
			{
				return null;
			}
			float num = def.uvs[0].x;
			float num2 = def.uvs[0].y;
			float num3 = def.uvs[0].x;
			float num4 = def.uvs[0].y;
			for (int i = 1; i < def.uvs.Length; i++)
			{
				num = Mathf.Min(num, def.uvs[i].x);
				num2 = Mathf.Min(num2, def.uvs[i].y);
				num3 = Mathf.Max(num3, def.uvs[i].x);
				num4 = Mathf.Max(num4, def.uvs[i].y);
			}
			float num5 = num * (float)((Texture)val).width;
			float num6 = num2 * (float)((Texture)val).height;
			float num7 = (num3 - num) * (float)((Texture)val).width;
			float num8 = (num4 - num2) * (float)((Texture)val).height;
			return Sprite.Create(val, new Rect(num5, num6, num7, num8), new Vector2(0.5f, 0.5f), ppu);
		}
	}
	public static class QuickWarpHook
	{
		private static QuickWarpGUI _gui;

		private static FieldInfo _areaNames;

		private static FieldInfo _scenesByArea;

		private static FieldInfo _transitionsByScene;

		private static FieldInfo _respawnsByScene;

		public static void Init()
		{
			_gui = Resources.FindObjectsOfTypeAll<QuickWarpGUI>().FirstOrDefault();
			if (Object.op_Implicit((Object)(object)_gui))
			{
				_areaNames = typeof(QuickWarpGUI).GetField("_areaNames", BindingFlags.Instance | BindingFlags.NonPublic);
				_scenesByArea = typeof(Warp).GetField("_scenes_by_area", BindingFlags.Static | BindingFlags.NonPublic);
				_transitionsByScene = typeof(Warp).GetField("_transitions_by_scene", BindingFlags.Static | BindingFlags.NonPublic);
				_respawnsByScene = typeof(Warp).GetField("_respawns_by_scene", BindingFlags.Static | BindingFlags.NonPublic);
				SceneUtils.QWHookEnabled = true;
			}
		}

		private static void RegisterGroup(string groupName)
		{
			List<string> list = ((string[])_areaNames.GetValue(_gui)).ToList();
			Dictionary<string, List<string>> dictionary = (Dictionary<string, List<string>>)_scenesByArea.GetValue(null);
			dictionary[groupName] = new List<string>();
			list.Add(groupName);
			_areaNames.SetValue(_gui, list.ToArray());
		}

		private static void UnregisterGroup(string groupName)
		{
			List<string> list = ((string[])_areaNames.GetValue(_gui)).ToList();
			list.Remove(groupName);
			Dictionary<string, List<string>> dictionary = (Dictionary<string, List<string>>)_scenesByArea.GetValue(null);
			dictionary.Remove(groupName);
			_areaNames.SetValue(_gui, list.ToArray());
		}

		public static void RegisterScene(string groupName, string sceneName)
		{
			Dictionary<string, List<string>> dictionary = (Dictionary<string, List<string>>)_scenesByArea.GetValue(null);
			if (!dictionary.ContainsKey(groupName))
			{
				RegisterGroup(groupName);
			}
			dictionary[groupName].Add(sceneName);
			((Dictionary<string, List<string>>)_transitionsByScene.GetValue(null))[sceneName] = new List<string>(1) { "_SceneManager" };
			((Dictionary<string, List<string>>)_respawnsByScene.GetValue(null))[sceneName] = new List<string>();
		}

		public static void UnregisterScene(string groupName, string sceneName)
		{
			Dictionary<string, List<string>> dictionary = (Dictionary<string, List<string>>)_scenesByArea.GetValue(null);
			if (dictionary.ContainsKey(groupName))
			{
				dictionary[groupName].Remove(sceneName);
				if (Extensions.IsNullOrEmpty<string>((ICollection<string>)dictionary[groupName]))
				{
					UnregisterGroup(groupName);
				}
			}
		}
	}
	public class QuickWarpHookLoader
	{
		public static void Init()
		{
			QuickWarpHook.Init();
		}

		public static void RegisterScene(string groupName, string sceneName)
		{
			QuickWarpHook.RegisterScene(groupName, sceneName);
		}

		public static void UnregisterScene(string groupName, string sceneName)
		{
			QuickWarpHook.UnregisterScene(groupName, sceneName);
		}
	}
	public static class ResourceUtils
	{
		[CompilerGenerated]
		private sealed class <LoadClip>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string clipPath;

			public Action<AudioClip> callback;

			private UnityWebRequest <www>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<www>5__1 = UnityWebRequestMultimedia.GetAudioClip(new Uri(clipPath), GetAudioType(clipPath));
					<>2__current = <www>5__1.SendWebRequest();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((int)<www>5__1.result == 1)
					{
						callback(DownloadHandlerAudioClip.GetContent(<www>5__1));
					}
					else
					{
						ArchitectPlugin.Logger.LogInfo((object)<www>5__1.error);
					}
					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();
			}
		}

		internal static Sprite LoadSpriteResource(string spritePath, FilterMode filterMode = 1, Vector4 border = default(Vector4), float ppu = 100f)
		{
			//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_0012: Unknown result type (might be due to invalid IL or missing references)
			return LoadSpriteResource(spritePath, new Vector2(0.5f, 0.5f), filterMode, border, ppu);
		}

		internal static Sprite LoadSpriteResource(string spritePath, Vector2 pivot, FilterMode filterMode = 1, Vector4 border = default(Vector4), float ppu = 100f)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			string name = "Architect.Resources." + spritePath + ".png";
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			using Stream stream = executingAssembly.GetManifestResourceStream(name);
			if (stream == null)
			{
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array, true);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), pivot, ppu, 0u, (SpriteMeshType)1, border);
			((Texture)val2.texture).filterMode = filterMode;
			return val2;
		}

		public static string LoadTextResource(string resourceName)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			using Stream stream = executingAssembly.GetManifestResourceStream("Architect.Resources." + resourceName);
			if (stream == null)
			{
				throw new Exception("Resource not found.");
			}
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		[CanBeNull]
		internal static Sprite[] LoadSprites(string spritePath, bool point, float ppu, int hcount, int vcount)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(spritePath))
			{
				return null;
			}
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, File.ReadAllBytes(spritePath), true);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)((!point) ? 1 : 0);
			Sprite[] array = (Sprite[])(object)new Sprite[hcount * vcount];
			float num = (float)((Texture)val).height / (float)vcount;
			float num2 = (float)((Texture)val).width / (float)hcount;
			int num3 = 0;
			for (int num4 = vcount - 1; num4 >= 0; num4--)
			{
				for (int i = 0; i < hcount; i++)
				{
					array[num3] = Sprite.Create(val, new Rect(num2 * (float)i, num * (float)num4, num2, num), new Vector2(0.5f, 0.5f), ppu);
					num3++;
				}
			}
			return array;
		}

		[IteratorStateMachine(typeof(<LoadClip>d__4))]
		internal static IEnumerator LoadClip(string clipPath, Action<AudioClip> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadClip>d__4(0)
			{
				clipPath = clipPath,
				callback = callback
			};
		}

		internal static void LoadClipResource(string clipPath, Action<AudioClip> callback)
		{
			string text = StorageManager.DataPath + "ModAssets/" + clipPath + ".wav";
			if (!File.Exists(text))
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				using Stream stream = executingAssembly.GetManifestResourceStream("Architect.Resources." + clipPath + ".wav");
				if (stream == null)
				{
					return;
				}
				using FileStream destination = new FileStream(text, FileMode.Create, FileAccess.Write);
				stream.CopyTo(destination);
			}
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadClip(text, callback));
		}

		private static AudioType GetAudioType(string fileName)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.GetExtension(fileName).ToLower();
			if (1 == 0)
			{
			}
			AudioType result;
			switch (text)
			{
			case ".wav":
				result = (AudioType)20;
				break;
			case ".mp3":
				result = (AudioType)13;
				break;
			case ".ogg":
				result = (AudioType)14;
				break;
			case ".aif":
			case ".aiff":
				result = (AudioType)2;
				break;
			default:
				result = (AudioType)0;
				break;
			}
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public static class SceneUtils
	{
		public delegate bool TryOpenQuickMap(GameMap self, out string displayName);

		public delegate void GetSceneInfo(GameMap self, string sceneName, MapZone mapZone, out GameMapScene foundScene, out GameObject foundSceneObj, out Vector2 foundScenePos);

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Action<GameObject> <>9__9_0;

			public static Action<GameObject> <>9__9_1;

			public static Action<GameObject> <>9__9_2;

			public static Func<Instruction, bool> <>9__9_11;

			public static Func<Instruction, bool> <>9__9_12;

			public static Func<Instruction, bool> <>9__9_13;

			public static Func<Instruction, bool> <>9__9_14;

			public static Func<Instruction, bool> <>9__9_15;

			public static Func<Instruction, bool> <>9__9_16;

			public static Func<Instruction, bool> <>9__9_17;

			public static Manipulator <>9__9_3;

			public static Action<Action<GameManager, string>, GameManager, string> <>9__9_4;

			public static Func<Func<InventoryMapManager, InventoryItemSelectable>, InventoryMapManager, InventoryItemSelectable> <>9__9_6;

			public static <>F{00000080}<TryOpenQuickMap, GameMap, string, bool> <>9__9_7;

			public static <>A{00092000}<GetSceneInfo, GameMap, string, MapZone, GameMapScene, GameObject, Vector2> <>9__9_8;

			public static Func<SceneGroup, bool> <>9__9_18;

			public static Func<Func<PlayerData, bool>, PlayerData, bool> <>9__9_9;

			public static Func<SceneGroup, bool> <>9__9_19;

			public static Action<Action<GameMap>, GameMap> <>9__9_10;

			public static Func<SceneGroup, bool> <>9__11_0;

			public static Func<AtmosCue, bool> <>9__18_0;

			internal void <Init>b__9_0(GameObject o)
			{
				o = Object.Instantiate<GameObject>(o);
				o.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)o);
				((Object)o).name = "[Architect] Managers Preload";
				_manager = o;
			}

			internal void <Init>b__9_1(GameObject o)
			{
				o = Object.Instantiate<GameObject>(o);
				o.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)o);
				((Object)o).name = "[Architect] Scene Manager Preload";
				_sceneManager = o;
			}

			internal void <Init>b__9_2(GameObject o)
			{
				o = Object.Instantiate<GameObject>(o);
				o.SetActive(false);
				tk2dTileMap component = o.GetComponent<tk2dTileMap>();
				((Behaviour)component).enabled = true;
				for (int i = 0; i < component.width; i++)
				{
					for (int j = 0; j < component.height; j++)
					{
						component.ClearTile(i, j, 0);
					}
				}
				Object.DontDestroyOnLoad((Object)(object)o);
				((Object)o).name = "[Architect] Tilemap Preload";
				_tilemap = o;
				tk2dTileMap component2 = _tilemap.GetComponent<tk2dTileMap>();
				Object.Destroy((Object)(object)component2.renderData);
			}

			internal void <Init>b__9_3(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[4]
				{
					(Instruction instr) => ILPatternMatchingExt.MatchLdloc(instr, 2),
					(Instruction instr) => instr.OpCode == OpCodes.Ldflda,
					(Instruction instr) => instr.OpCode == OpCodes.Call,
					(Instruction instr) => instr.OpCode == OpCodes.Brfalse_S
				});
				ILLabel val2 = val.MarkLabel();
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[3]
				{
					(Instruction instr) => ILPatternMatchingExt.MatchLdloc(instr, 2),
					(Instruction instr) => instr.OpCode == OpCodes.Ldc_I4_4,
					(Instruction instr) => instr.OpCode == OpCodes.Call
				});
				ILLabel val3 = val.MarkLabel();
				val.GotoLabel(val2, (MoveType)1, false);
				val.Emit(OpCodes.Br, (object)val3);
			}

			internal bool <Init>b__9_11(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdloc(instr, 2);
			}

			internal bool <Init>b__9_12(Instruction instr)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return instr.OpCode == OpCodes.Ldflda;
			}

			internal bool <Init>b__9_13(Instruction instr)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return instr.OpCode == OpCodes.Call;
			}

			internal bool <Init>b__9_14(Instruction instr)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return instr.OpCode == OpCodes.Brfalse_S;
			}

			internal bool <Init>b__9_15(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdloc(instr, 2);
			}

			internal bool <Init>b__9_16(Instruction instr)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return instr.OpCode == OpCodes.Ldc_I4_4;
			}

			internal bool <Init>b__9_17(Instruction instr)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return instr.OpCode == OpCodes.Call;
			}

			internal void <Init>b__9_4(Action<GameManager, string> orig, GameManager self, string destScene)
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				if (CustomScenes.ContainsKey(destScene))
				{
					StorageManager.SaveScene(self.sceneName, PlacementManager.GetLevelData());
					StorageManager.SaveScene("Global", PlacementManager.GetGlobalData());
					PersistentAudioManager.OnLeaveScene();
					PersistentAudioManager.QueueSceneEntry();
					self.startedOnThisScene = false;
					self.nextSceneName = destScene;
					self.LastSceneLoad = new SceneLoad((MonoBehaviour)(object)self, new SceneLoadInfo
					{
						SceneName = destScene
					});
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadScene(destScene));
				}
				else
				{
					orig(self, destScene);
				}
			}

			internal InventoryItemSelectable <Init>b__9_6(Func<InventoryMapManager, InventoryItemSelectable> orig, InventoryMapManager self)
			{
				if (CustomScenes.TryGetValue(GameManager.instance.sceneName, out var value) && SceneGroups.TryGetValue(value.Group, out var value2) && value2.HasMap())
				{
					return (InventoryItemSelectable)(object)value2.MapZone;
				}
				return orig(self);
			}

			internal bool <Init>b__9_7(TryOpenQuickMap orig, GameMap self, out string displayName)
			{
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				displayName = string.Empty;
				if (CustomScenes.TryGetValue(GameManager.instance.sceneName, out var value))
				{
					if (!SceneGroups.TryGetValue(value.Group, out var value2) || !value2.HasMap())
					{
						return false;
					}
					self.DisableAllAreas();
					self.EnableUnlockedAreas((MapZone?)(MapZone)0);
					displayName = value2.GroupName;
					((Component)self).transform.localScale = new Vector3(1.4725f, 1.4725f, 1f);
					Extensions.SetPosition2D(((Component)self).transform, value2.ZoomPos * -1.4725f);
					if (value.Map.activeInHierarchy)
					{
						string heroCorpseScene = PlayerData.instance.HeroCorpseScene;
						if (heroCorpseScene != null && CustomScenes.TryGetValue(heroCorpseScene, out var value3) && SceneGroups.TryGetValue(value3.Group, out var value4) && value4 == value2)
						{
							self.shadeMarker.SetActive(true);
						}
						self.PositionCompassAndCorpse();
					}
					self.SetDisplayNextArea(true, (MapZone)0);
					self.SetupMapMarkers();
					return true;
				}
				return orig(self, out displayName);
			}

			internal void <Init>b__9_8(GetSceneInfo orig, GameMap self, string sceneName, MapZone mapZone, out GameMapScene foundScene, out GameObject foundSceneObj, out Vector2 foundScenePos)
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				if (sceneName != null && CustomScenes.TryGetValue(sceneName, out var value) && Object.op_Implicit((Object)(object)value.Map))
				{
					foundScene = value.Gms;
					foundSceneObj = value.Map;
					Vector3 localPosition = foundSceneObj.transform.localPosition;
					Vector3 localPosition2 = foundSceneObj.transform.parent.localPosition;
					Vector3 val = localPosition + localPosition2;
					float? num = 0f;
					foundScenePos = Vector2.op_Implicit(Extensions.Where(val, (float?)null, (float?)null, num));
					if (!foundSceneObj.activeInHierarchy)
					{
						foundSceneObj = null;
					}
				}
				else
				{
					orig(self, sceneName, mapZone, out foundScene, out foundSceneObj, out foundScenePos);
				}
			}

			internal bool <Init>b__9_9(Func<PlayerData, bool> orig, PlayerData self)
			{
				return orig(self) || SceneGroups.Values.Any((SceneGroup sg) => sg.HasMap());
			}

			internal bool <Init>b__9_18(SceneGroup sg)
			{
				return sg.HasMap();
			}

			internal void <Init>b__9_10(Action<GameMap> _, GameMap self)
			{
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				//IL_024c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0278: Unknown result type (might be due to invalid IL or missing references)
				//IL_026c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0298: Unknown result type (might be due to invalid IL or missing references)
				//IL_058a: Unknown result type (might be due to invalid IL or missing references)
				//IL_058c: Unknown result type (might be due to invalid IL or missing references)
				//IL_059c: Unknown result type (might be due to invalid IL or missing references)
				//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Invalid comparison between Unknown and I4
				//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_072a: Unknown result type (might be due to invalid IL or missing references)
				//IL_072c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0737: Unknown result type (might be due to invalid IL or missing references)
				//IL_0739: Unknown result type (might be due to invalid IL or missing references)
				//IL_0744: Unknown result type (might be due to invalid IL or missing references)
				//IL_0746: Unknown result type (might be due to invalid IL or missing references)
				//IL_074b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0751: Unknown result type (might be due to invalid IL or missing references)
				//IL_0756: Unknown result type (might be due to invalid IL or missing references)
				//IL_075b: Unknown result type (might be due to invalid IL or missing references)
				//IL_075d: Unknown result type (might be due to invalid IL or missing references)
				//IL_077e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0783: Unknown result type (might be due to invalid IL or missing references)
				//IL_0788: Unknown result type (might be due to invalid IL or missing references)
				//IL_078a: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0303: Unknown result type (might be due to invalid IL or missing references)
				//IL_0308: Unknown result type (might be due to invalid IL or missing references)
				//IL_0313: Unknown result type (might be due to invalid IL or missing references)
				//IL_0318: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_083a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0853: Unknown result type (might be due to invalid IL or missing references)
				//IL_086c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0885: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0804: Unknown result type (might be due to invalid IL or missing references)
				//IL_081b: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0332: Unknown result type (might be due to invalid IL or missing references)
				//IL_032a: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0409: Unknown result type (might be due to invalid IL or missing references)
				//IL_0410: Unknown result type (might be due to invalid IL or missing references)
				//IL_0415: Unknown result type (might be due to invalid IL or missing references)
				//IL_041a: Unknown result type (might be due to invalid IL or missing references)
				//IL_041c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0899: Unknown result type (might be due to invalid IL or missing references)
				//IL_089b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Expected O, but got Unknown
				//IL_0448: Unknown result type (might be due to invalid IL or missing references)
				//IL_043c: Unknown result type (might be due to invalid IL or missing references)
				//IL_061a: Unknown result type (might be due to invalid IL or missing references)
				//IL_062a: Unknown result type (might be due to invalid IL or missing references)
				//IL_062f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0634: Unknown result type (might be due to invalid IL or missing references)
				//IL_0474: Unknown result type (might be due to invalid IL or missing references)
				//IL_0468: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0494: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0660: Unknown result type (might be due to invalid IL or missing references)
				//IL_0665: Unknown result type (might be due to invalid IL or missing references)
				//IL_0668: Expected O, but got Unknown
				//IL_0669: Expected O, but got Unknown
				//IL_071b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0505: Unknown result type (might be due to invalid IL or missing references)
				//IL_050a: Unknown result type (might be due to invalid IL or missing references)
				//IL_050e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0510: Unknown result type (might be due to invalid IL or missing references)
				//IL_0517: Unknown result type (might be due to invalid IL or missing references)
				//IL_0521: Unknown result type (might be due to invalid IL or missing references)
				//IL_053e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0536: Unknown result type (might be due to invalid IL or missing references)
				//IL_0538: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
				<>c__DisplayClass9_1 CS$<>8__locals0 = new <>c__DisplayClass9_1
				{
					self = self
				};
				CS$<>8__locals0.self.CompleteVisibleLocalBoundsNow();
				if (CS$<>8__locals0.self.updatePinAreaBounds)
				{
					CS$<>8__locals0.self.CalculatePinAreaBounds();
				}
				CS$<>8__locals0.self.panMinX = float.MaxValue;
				CS$<>8__locals0.self.panMaxX = float.MinValue;
				CS$<>8__locals0.self.panMinY = float.MaxValue;
				CS$<>8__locals0.self.panMaxY = float.MinValue;
				PlayerData instance = PlayerData.instance;
				MapZone val = (MapZone)(CS$<>8__locals0.self.displayingCompass ? ((int)CS$<>8__locals0.self.GetCurrentMapZone()) : 0);
				bool flag = CollectableItemManager.IsInHiddenMode();
				bool flag2 = CS$<>8__locals0.self.IsLostInAbyssPostMap();
				bool flag3 = flag || flag2;
				Bounds val2 = default(Bounds);
				int num = 0;
				Bounds val7 = default(Bounds);
				for (int i = 0; i < CS$<>8__locals0.self.mapZoneInfo.Length; i++)
				{
					ZoneInfo val3 = CS$<>8__locals0.self.mapZoneInfo[i];
					MapZone val4 = (MapZone)i;
					bool flag4 = false;
					ParentInfo[] parents = val3.Parents;
					foreach (ParentInfo val5 in parents)
					{
						if (!Object.op_Implicit((Object)(object)val5.Parent))
						{
							continue;
						}
						if (val4 != val && !val5.Parent.gameObject.activeSelf)
						{
							if ((int)val5.BoundsAddedByPinGroup == -1 || flag || flag2)
							{
								continue;
							}
							string text = CaravanTroupeHunter.PdBools[val5.BoundsAddedByPinGroup];
							if (!VariableExtensions.GetVariable<bool>((IIncludeVariableExtensions)(object)instance, text) || !CS$<>8__locals0.self.HasRemainingPinFor(val5.BoundsAddedByPinGroup))
							{
								continue;
							}
						}
						foreach (Transform item in val5.Parent.transform)
						{
							Transform val6 = item;
							if (((Component)val6).gameObject.activeSelf)
							{
								SpriteRenderer component = ((Component)val6).GetComponent<SpriteRenderer>();
								if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.sprite))
								{
									flag4 = true;
									break;
								}
							}
						}
						if (flag4)
						{
							break;
						}
					}
					if (flag4)
					{
						Vector2 wideMapZoomPositionNew = val3.GetWideMapZoomPositionNew();
						if (wideMapZoomPositionNew.x < CS$<>8__locals0.self.panMinX)
						{
							CS$<>8__locals0.self.panMinX = wideMapZoomPositionNew.x;
						}
						if (wideMapZoomPositionNew.x > CS$<>8__locals0.self.panMaxX)
						{
							CS$<>8__locals0.self.panMaxX = wideMapZoomPositionNew.x;
						}
						if (wideMapZoomPositionNew.y < CS$<>8__locals0.self.panMinY)
						{
							CS$<>8__locals0.self.panMinY = wideMapZoomPositionNew.y;
						}
						if (wideMapZoomPositionNew.y > CS$<>8__locals0.self.panMaxY)
						{
							CS$<>8__locals0.self.panMaxY = wideMapZoomPositionNew.y;
						}
						Vector3 size = ((Bounds)(ref val3.VisibleLocalBounds)).size;
						((Bounds)(ref val7))..ctor(((Bounds)(ref val3.VisibleLocalBounds)).center, size);
						if (num == 0)
						{
							val2 = val7;
						}
						else
						{
							((Bounds)(ref val2)).Encapsulate(val7);
						}
						num++;
					}
				}
				using (IEnumerator<SceneGroup> enumerator2 = SceneGroups.Values.Where((SceneGroup group) => group.HasMap()).Distinct().GetEnumerator())
				{
					Bounds val9 = default(Bounds);
					while (enumerator2.MoveNext())
					{
						<>c__DisplayClass9_2 CS$<>8__locals1 = new <>c__DisplayClass9_2
						{
							group = enumerator2.Current
						};
						foreach (CustomScene item2 in CustomScenes.Values.Where((CustomScene o) => o.Group == CS$<>8__locals1.group.Id))
						{
							Vector2 val8 = CS$<>8__locals1.group.ZoomPos + item2.MapPos;
							if (val8.x < CS$<>8__locals0.self.panMinX)
							{
								CS$<>8__locals0.self.panMinX = val8.x;
							}
							if (val8.x > CS$<>8__locals0.self.panMaxX)
							{
								CS$<>8__locals0.self.panMaxX = val8.x;
							}
							if (val8.y < CS$<>8__locals0.self.panMinY)
							{
								CS$<>8__locals0.self.panMinY = val8.y;
							}
							if (val8.y > CS$<>8__locals0.self.panMaxY)
							{
								CS$<>8__locals0.self.panMaxY = val8.y;
							}
							if (Object.op_Implicit((Object)(object)item2.Gms) && Object.op_Implicit((Object)(object)item2.Gms.fullSprite))
							{
								Bounds croppedBounds = GameMapScene.GetCroppedBounds(item2.Gms.fullSprite);
								((Bounds)(ref val9))..ctor(Vector2.op_Implicit(val8), ((Bounds)(ref croppedBounds)).extents * 1.15f);
								if (num == 0)
								{
									val2 = val9;
								}
								else
								{
									((Bounds)(ref val2)).Encapsulate(val9);
								}
								num++;
							}
						}
					}
				}
				CS$<>8__locals0.self.mapBounds = val2;
				Vector3 center = ((Bounds)(ref CS$<>8__locals0.self.mapMarkerScrollArea)).center;
				ArrayForEnumAttribute.EnsureArraySize<WrappedVector2List>(ref instance.placedMarkers, typeof(MarkerTypes));
				if (!flag3)
				{
					Bounds val10 = default(Bounds);
					bool flag5 = false;
					if (Object.op_Implicit((Object)(object)CS$<>8__locals0.self.markerParent) && (Object)(object)CS$<>8__locals0.self.markerParent != (Object)(object)((Component)CS$<>8__locals0.self).transform)
					{
						CS$<>8__locals0.self.markerToGameMapLocal = ((Component)CS$<>8__locals0.self).transform.worldToLocalMatrix * CS$<>8__locals0.self.markerParent.localToWorldMatrix;
					}
					for (int k = 0; k < CS$<>8__locals0.self.spawnedMapMarkers.GetLength(0); k++)
					{
						WrappedVector2List val11 = instance.placedMarkers[k];
						if (val11 == null)
						{
							WrappedVector2List[] placedMarkers = instance.placedMarkers;
							int num2 = k;
							WrappedVector2List val12 = new WrappedVector2List();
							val11 = val12;
							placedMarkers[num2] = val12;
						}
						foreach (Vector3 item3 in ((WrappedList<Vector2>)(object)val11).List.Select((Vector2 t) => ((Matrix4x4)(ref CS$<>8__locals0.self.markerToGameMapLocal)).MultiplyPoint3x4(Vector2.op_Implicit(t))))
						{
							if (flag5)
							{
								((Bounds)(ref val10)).Encapsulate(item3);
								continue;
							}
							val10 = new Bounds(item3, Vector3.zero);
							flag5 = true;
						}
					}
					if (flag5)
					{
						((Bounds)(ref val2)).Encapsulate(val10);
					}
				}
				CS$<>8__locals0.self.MapMarkerBounds = val2;
				CS$<>8__locals0.self.NoPanBounds = val2;
				Bounds zoomedBounds = CS$<>8__locals0.self.ApplyScrollAreaOffset(val2);
				((Bounds)(ref zoomedBounds)).center = -((Bounds)(ref zoomedBounds)).center + center;
				((Bounds)(ref CS$<>8__locals0.self.MapMarkerBounds)).center = -((Bounds)(ref CS$<>8__locals0.self.MapMarkerBounds)).center + center;
				((Bounds)(ref CS$<>8__locals0.self.NoPanBounds)).center = -((Bounds)(ref CS$<>8__locals0.self.NoPanBounds)).center + center;
				if (num > 1)
				{
					CS$<>8__locals0.self.panMinX = ((Bounds)(ref zoomedBounds)).min.x;
					CS$<>8__locals0.self.panMinY = ((Bounds)(ref zoomedBounds)).min.y;
					CS$<>8__locals0.self.panMaxX = ((Bounds)(ref zoomedBounds)).max.x;
					CS$<>8__locals0.self.panMaxY = ((Bounds)(ref zoomedBounds)).max.y;
				}
				else
				{
					GameMap self2 = CS$<>8__locals0.self;
					self2.panMinX += center.x;
					GameMap self3 = CS$<>8__locals0.self;
					self3.panMaxX += center.x;
					GameMap self4 = CS$<>8__locals0.self;
					self4.panMinY += center.y;
					GameMap self5 = CS$<>8__locals0.self;
					self5.panMaxY += center.y;
				}
				CS$<>8__locals0.self.ZoomedBounds = zoomedBounds;
			}

			internal bool <Init>b__9_19(SceneGroup group)
			{
				return group.HasMap();
			}

			internal bool <AdjustMapScale>b__11_0(SceneGroup g)
			{
				return g.HasMapZone && Object.op_Implicit((Object)(object)g.MapSprite);
			}

			internal bool <get_NoAtmosCue>b__18_0(AtmosCue o)
			{
				return ((Object)o).name == "None";
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			public SceneLoad self;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass9_1
		{
			public GameMap self;

			public Func<Vector2, Vector3> <>9__21;

			internal Vector3 <Init>b__21(Vector2 t)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				return ((Matrix4x4)(ref self.markerToGameMapLocal)).MultiplyPoint3x4(Vector2.op_Implicit(t));
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass9_2
		{
			public SceneGroup group;

			public Func<CustomScene, bool> <>9__20;

			internal bool <Init>b__20(CustomScene o)
			{
				return o.Group == group.Id;
			}
		}

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

			private object <>2__current;

			public string sceneName;

			private string <current>5__1;

			private CustomScene <info>5__2;

			private Scene <scene>5__3;

			private GameObject <sm>5__4;

			private TransitionPoint <point>5__5;

			private BoxCollider2D <col>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<current>5__1 = null;
				<info>5__2 = null;
				<sm>5__4 = null;
				<point>5__5 = null;
				<col>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<current>5__1 = GameManager.instance.sceneName;
					if (<current>5__1 == sceneName)
					{
						SceneManager.MergeScenes(SceneManager.GetActiveScene(), SceneManager.CreateScene("Temp"));
						<current>5__1 = "Temp";
					}
					<info>5__2 = CustomScenes[sceneName];
					<scene>5__3 = SceneManager.CreateScene(sceneName);
					<sm>5__4 = CreateSceneManager();
					<sm>5__4.GetComponent<CustomSceneManager>().environmentType = <info>5__2.Environment;
					SceneManager.MoveGameObjectToScene(<sm>5__4, <scene>5__3);
					SceneManager.MoveGameObjectToScene(CreateManager(), <scene>5__3);
					SceneManager.SetActiveScene(<scene>5__3);
					CreateTileMap(<info>5__2);
					<sm>5__4.AddComponent<CustomTransitionPoint>();
					<point>5__5 = <sm>5__4.AddComponent<TransitionPoint>();
					<point>5__5.nonHazardGate = true;
					<point>5__5.targetScene = "Belltown";
					<point>5__5.entryPoint = "door1";
					<col>5__6 = <sm>5__4.AddComponent<BoxCollider2D>();
					<col>5__6.size = new Vector2(0f, 0f);
					((Collider2D)<col>5__6).offset = new Vector2(-9999f, -9999f);
					((Collider2D)<col>5__6).isTrigger = true;
					<>2__current = SceneManager.UnloadSceneAsync(<current>5__1);
					<>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();
			}
		}

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

			private object <>2__current;

			public Func<SceneLoad, IEnumerator> orig;

			public SceneLoad self;

			private <>c__DisplayClass14_0 <>8__1;

			private IEnumerator <o>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<o>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Expected O, but got Unknown
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass14_0();
					<>8__1.self = self;
					<o>5__2 = orig(<>8__1.self);
					if (CustomScenes.ContainsKey(<>8__1.self.TargetSceneName))
					{
						<>8__1.self.ActivationComplete += new ActivationCompleteDelegate(Load);
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<o>5__2.MoveNext())
				{
					<>2__current = <o>5__2.Current;
					<>1__state = 1;
					return true;
				}
				<>8__1.self.ActivationComplete -= new ActivationCompleteDelegate(Load);
				return false;
				void Load()
				{
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadScene(((<>c__DisplayClass14_0)this).self.TargetSceneName));
				}
			}

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

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

		private static GameObject _manager;

		private static GameObject _sceneManager;

		private static GameObject _tilemap;

		private static GameObject _borderPrefab;

		public static tk2dTileMap Tilemap;

		public static readonly Dictionary<string, CustomScene> CustomScenes = new Dictionary<string, CustomScene>();

		public static readonly Dictionary<string, SceneGroup> SceneGroups = new Dictionary<string, SceneGroup>();

		public static bool QWHookEnabled;

		private static readonly FieldInfo SceneMapStartScale = typeof(InventoryMapManager).GetField("SceneMapStartScale", BindingFlags.Static | BindingFlags.Public);

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private static AtmosCue <NoAtmosCue>k__BackingField;

		private static AtmosCue NoAtmosCue => <NoAtmosCue>k__BackingField ?? (<NoAtmosCue>k__BackingField = ((IEnumerable<AtmosCue>)Resources.FindObjectsOfTypeAll<AtmosCue>()).FirstOrDefault((Func<AtmosCue, bool>)((AtmosCue o) => ((Object)o).name == "None")));

		public static void InitQWHook()
		{
			if (Chainloader.PluginInfos.ContainsKey("io.github.hk-speedrunning.quickwarp"))
			{
				ArchitectPlugin.Logger.LogInfo((object)"Enabling QuickWarp Hook");
				QuickWarpHookLoader.Init();
			}
		}

		public static void Init()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			_borderPrefab = new GameObject("[Architect] Border Replacement");
			_borderPrefab.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_borderPrefab);
			PreloadManager.RegisterPreload(new BasicPreload("Arborium_09", "_Managers", delegate(GameObject o)
			{
				o = Object.Instantiate<GameObject>(o);
				o.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)o);
				((Object)o).name = "[Architect] Managers Preload";
				_manager = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Arborium_09", "_SceneManager", delegate(GameObject o)
			{
				o = Object.Instantiate<GameObject>(o);
				o.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)o);
				((Object)o).name = "[Architect] Scene Manager Preload";
				_sceneManager = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Arborium_09", "TileMap", delegate(GameObject o)
			{
				o = Object.Instantiate<GameObject>(o);
				o.SetActive(false);
				tk2dTileMap component2 = o.GetComponent<tk2dTileMap>();
				((Behaviour)component2).enabled = true;
				for (int l = 0; l < component2.width; l++)
				{
					for (int m = 0; m < component2.height; m++)
					{
						component2.ClearTile(l, m, 0);
					}
				}
				Object.DontDestroyOnLoad((Object)(object)o);
				((Object)o).name = "[Architect] Tilemap Preload";
				_tilemap = o;
				tk2dTileMap component3 = _tilemap.GetComponent<tk2dTileMap>();
				Object.Destroy((Object)(object)component3.renderData);
			}));
			typeof(SceneLoad).Hook("BeginRoutine", new Func<Func<SceneLoad, IEnumerator>, SceneLoad, IEnumerator>(RedirectLoad));
			MethodInfo stateMachineTarget = Extensions.GetStateMachineTarget(typeof(SceneLoad).GetMethod("BeginRoutine", BindingFlags.Instance | BindingFlags.NonPublic));
			object obj = <>c.<>9__9_3;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_012b: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val15 = new ILCursor(il);
					val15.GotoNext((MoveType)2, new Func<Instruction, bool>[4]
					{
						(Instruction instr) => ILPatternMatchingExt.MatchLdloc(instr, 2),
						(Instruction instr) => instr.OpCode == OpCodes.Ldflda,
						(Instruction instr) => instr.OpCode == OpCodes.Call,
						(Instruction instr) => instr.OpCode == OpCodes.Brfalse_S
					});
					ILLabel val16 = val15.MarkLabel();
					val15.GotoNext((MoveType)2, new Func<Instruction, bool>[3]
					{
						(Instruction instr) => ILPatternMatchingExt.MatchLdloc(instr, 2),
						(Instruction instr) => instr.OpCode == OpCodes.Ldc_I4_4,
						(Instruction instr) => instr.OpCode == OpCodes.Call
					});
					ILLabel val17 = val15.MarkLabel();
					val15.GotoLabel(val16, (MoveType)1, false);
					val15.Emit(OpCodes.Br, (object)val17);
				};
				<>c.<>9__9_3 = val;
				obj = (object)val;
			}
			new ILHook((MethodBase)stateMachineTarget, (Manipulator)obj);
			typeof(GameManager).Hook("LoadScene", (Action<Action<GameManager, string>, GameManager, string>)delegate(Action<GameManager, string> orig, GameManager self, string destScene)
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				if (CustomScenes.ContainsKey(destScene))
				{
					StorageManager.SaveScene(self.sceneName, PlacementManager.GetLevelData());
					StorageManager.SaveScene("Global", PlacementManager.GetGlobalData());
					PersistentAudioManager.OnLeaveScene();
					PersistentAudioManager.QueueSceneEntry();
					self.startedOnThisScene = false;
					self.nextSceneName = destScene;
					self.LastSceneLoad = new SceneLoad((MonoBehaviour)(object)self, new SceneLoadInfo
					{
						SceneName = destScene
					});
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadScene(destScene));
				}
				else
				{
					orig(self, destScene);
				}
			});
			AreaBackground blankBackground = new AreaBackground
			{
				BackgroundImage = ArchitectPlugin.BlankSprite,
				NameOverride = new LocalisedString("ArchitectMod", "???")
			};
			typeof(SaveSlotBackgrounds).Hook("GetBackground", (Func<Func<SaveSlotBackgrounds, SaveStats, AreaBackground>, SaveSlotBackgrounds, SaveStats, AreaBackground>)delegate(Func<SaveSlotBackgrounds, SaveStats, AreaBackground> orig, SaveSlotBackgrounds self, SaveStats currentSaveStats)
			{
				string key = currentSaveStats?.saveGameData?.playerData?.respawnScene ?? "";
				CustomScene value8;
				SceneGroup value9;
				return CustomScenes.TryGetValue(key, out value8) ? (SceneGroups.TryGetValue(value8.Group, out value9) ? (value9.Background ?? blankBackground) : blankBackground) : orig(self, currentSaveStats);
			}, typeof(SaveStats));
			typeof(InventoryMapManager).Hook("GetStartSelectable", (Func<Func<InventoryMapManager, InventoryItemSelectable>, InventoryMapManager, InventoryItemSelectable>)((Func<InventoryMapManager, InventoryItemSelectable> orig, InventoryMapManager self) => (InventoryItemSelectable)((CustomScenes.TryGetValue(GameManager.instance.sceneName, out var value6) && SceneGroups.TryGetValue(value6.Group, out var value7) && value7.HasMap()) ? ((object)value7.MapZone) : ((object)orig(self)))));
			typeof(GameMap).Hook("TryOpenQuickMap", (<>F{00000080}<TryOpenQuickMap, GameMap, string, bool>)delegate(TryOpenQuickMap orig, GameMap self, out string displayName)
			{
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				displayName = string.Empty;
				if (CustomScenes.TryGetValue(GameManager.instance.sceneName, out var value2))
				{
					if (!SceneGroups.TryGetValue(value2.Group, out var value3) || !value3.HasMap())
					{
						return false;
					}
					self.DisableAllAreas();
					self.EnableUnlockedAreas((MapZone?)(MapZone)0);
					displayName = value3.GroupName;
					((Component)self).transform.localScale = new Vector3(1.4725f, 1.4725f, 1f);
					Extensions.SetPosition2D(((Component)self).transform, value3.ZoomPos * -1.4725f);
					if (value2.Map.activeInHierarchy)
					{
						string heroCorpseScene = PlayerData.instance.HeroCorpseScene;
						if (heroCorpseScene != null && CustomScenes.TryGetValue(heroCorpseScene, out var value4) && SceneGroups.TryGetValue(value4.Group, out var value5) && value5 == value3)
						{
							self.shadeMarker.SetActive(true);
						}
						self.PositionCompassAndCorpse();
					}
					self.SetDisplayNextArea(true, (MapZone)0);
					self.SetupMapMarkers();
					return true;
				}
				return orig(self, out displayName);
			});
			typeof(GameMap).Hook("GetSceneInfo", (<>A{00092000}<GetSceneInfo, GameMap, string, MapZone, GameMapScene, GameObject, Vector2>)delegate(GetSceneInfo orig, GameMap self, string sceneName, MapZone mapZone, out GameMapScene foundScene, out GameObject foundSceneObj, out Vector2 foundScenePos)
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				if (sceneName != null && CustomScenes.TryGetValue(sceneName, out var value) && Object.op_Implicit((Object)(object)value.Map))
				{
					foundScene = value.Gms;
					foundSceneObj = value.Map;
					Vector3 localPosition = foundSceneObj.transform.localPosition;
					Vector3 localPosition2 = foundSceneObj.transform.parent.localPosition;
					Vector3 val14 = localPosition + localPosition2;
					float? num3 = 0f;
					foundScenePos = Vector2.op_Implicit(Extensions.Where(val14, (float?)null, (float?)null, num3));
					if (!foundSceneObj.activeInHierarchy)
					{
						foundSceneObj = null;
					}
				}
				else
				{
					orig(self, sceneName, mapZone, out foundScene, out foundSceneObj, out foundScenePos);
				}
			});
			new Hook((MethodBase)typeof(PlayerData).GetProperty("HasAnyMap").GetGetMethod(), (Delegate)(Func<Func<PlayerData, bool>, PlayerData, bool>)((Func<PlayerData, bool> orig, PlayerData self) => orig(self) || SceneGroups.Values.Any((SceneGroup sg) => sg.HasMap())));
			typeof(GameMap).Hook("CalculateMapScrollBounds", (Action<Action<GameMap>, GameMap>)delegate(Action<GameMap> _, GameMap self)
			{
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				//IL_024c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0278: Unknown result type (might be due to invalid IL or missing references)
				//IL_026c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0298: Unknown result type (might be due to invalid IL or missing references)
				//IL_058a: Unknown result type (might be due to invalid IL or missing references)
				//IL_058c: Unknown result type (might be due to invalid IL or missing references)
				//IL_059c: Unknown result type (might be due to invalid IL or missing references)
				//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Invalid comparison between Unknown and I4
				//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_072a: Unknown result type (might be due to invalid IL or missing references)
				//IL_072c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0737: Unknown result type (might be due to invalid IL or missing references)
				//IL_0739: Unknown result type (might be due to invalid IL or missing references)
				//IL_0744: Unknown result type (might be due to invalid IL or missing references)
				//IL_0746: Unknown result type (might be due to invalid IL or missing references)
				//IL_074b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0751: Unknown result type (might be due to invalid IL or missing references)
				//IL_0756: Unknown result type (might be due to invalid IL or missing references)
				//IL_075b: Unknown result type (might be due to invalid IL or missing references)
				//IL_075d: Unknown result type (might be due to invalid IL or missing references)
				//IL_077e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0783: Unknown result type (might be due to invalid IL or missing references)
				//IL_0788: Unknown result type (might be due to invalid IL or missing references)
				//IL_078a: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_07b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0303: Unknown result type (might be due to invalid IL or missing references)
				//IL_0308: Unknown result type (might be due to invalid IL or missing references)
				//IL_0313: Unknown result type (might be due to invalid IL or missing references)
				//IL_0318: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_083a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0853: Unknown result type (might be due to invalid IL or missing references)
				//IL_086c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0885: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0804: Unknown result type (might be due to invalid IL or missing references)
				//IL_081b: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0332: Unknown result type (might be due to invalid IL or missing references)
				//IL_032a: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0409: Unknown result type (might be due to invalid IL or missing references)
				//IL_0410: Unknown result type (might be due to invalid IL or missing references)
				//IL_0415: Unknown result type (might be due to invalid IL or missing references)
				//IL_041a: Unknown result type (might be due to invalid IL or missing references)
				//IL_041c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0899: Unknown result type (might be due to invalid IL or missing references)
				//IL_089b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Expected O, but got Unknown
				//IL_0448: Unknown result type (might be due to invalid IL or missing references)
				//IL_043c: Unknown result type (might be due to invalid IL or missing references)
				//IL_061a: Unknown result type (might be due to invalid IL or missing references)
				//IL_062a: Unknown result type (might be due to invalid IL or missing references)
				//IL_062f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0634: Unknown result type (might be due to invalid IL or missing references)
				//IL_0474: Unknown result type (might be due to invalid IL or missing references)
				//IL_0468: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0494: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0660: Unknown result type (might be due to invalid IL or missing references)
				//IL_0665: Unknown result type (might be due to invalid IL or missing references)
				//IL_0668: Expected O, but got Unknown
				//IL_0669: Expected O, but got Unknown
				//IL_071b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0505: Unknown result type (might be due to invalid IL or missing references)
				//IL_050a: Unknown result type (might be due to invalid IL or missing references)
				//IL_050e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0510: Unknown result type (might be due to invalid IL or missing references)
				//IL_0517: Unknown result type (might be due to invalid IL or missing references)
				//IL_0521: Unknown result type (might be due to invalid IL or missing references)
				//IL_053e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0536: Unknown result type (might be due to invalid IL or missing references)
				//IL_0538: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
				self.CompleteVisibleLocalBoundsNow();
				if (self.updatePinAreaBounds)
				{
					self.CalculatePinAreaBounds();
				}
				self.panMinX = float.MaxValue;
				self.panMaxX = float.MinValue;
				self.panMinY = float.MaxValue;
				self.panMaxY = float.MinValue;
				PlayerData instance = PlayerData.instance;
				MapZone val2 = (MapZone)(self.displayingCompass ? ((int)self.GetCurrentMapZone()) : 0);
				bool flag = CollectableItemManager.IsInHiddenMode();
				bool flag2 = self.IsLostInAbyssPostMap();
				bool flag3 = flag || flag2;
				Bounds val3 = default(Bounds);
				int num = 0;
				Bounds val8 = default(Bounds);
				for (int i = 0; i < self.mapZoneInfo.Length; i++)
				{
					ZoneInfo val4 = self.mapZoneInfo[i];
					MapZone val5 = (MapZone)i;
					bool flag4 = false;
					ParentInfo[] parents = val4.Parents;
					foreach (ParentInfo val6 in parents)
					{
						if (Object.op_Implicit((Object)(object)val6.Parent))
						{
							if (val5 != val2 && !val6.Parent.gameObject.activeSelf)
							{
								if ((int)val6.BoundsAddedByPinGroup == -1 || flag || flag2)
								{
									continue;
								}
								string text = CaravanTroupeHunter.PdBools[val6.BoundsAddedByPinGroup];
								if (!VariableExtensions.GetVariable<bool>((IIncludeVariableExtensions)(object)instance, text) || !self.HasRemainingPinFor(val6.BoundsAddedByPinGroup))
								{
									continue;
								}
							}
							foreach (Transform item in val6.Parent.transform)
							{
								Transform val7 = item;
								if (((Component)val7).gameObject.activeSelf)
								{
									SpriteRenderer component = ((Component)val7).GetComponent<SpriteRenderer>();
									if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.sprite))
									{
										flag4 = true;
										break;
									}
								}
							}
							if (flag4)
							{
								break;
							}
						}
					}
					if (flag4)
					{
						Vector2 wideMapZoomPositionNew = val4.GetWideMapZoomPositionNew();
						if (wideMapZoomPositionNew.x < self.panMinX)
						{
							self.panMinX = wideMapZoomPositionNew.x;
						}
						if (wideMapZoomPositionNew.x > self.panMaxX)
						{
							self.panMaxX = wideMapZoomPositionNew.x;
						}
						if (wideMapZoomPositionNew.y < self.panMinY)
						{
							self.panMinY = wideMapZoomPositionNew.y;
						}
						if (wideMapZoomPositionNew.y > self.panMaxY)
						{
							self.panMaxY = wideMapZoomPositionNew.y;
						}
						Vector3 size = ((Bounds)(ref val4.VisibleLocalBounds)).size;
						((Bounds)(ref val8))..ctor(((Bounds)(ref val4.VisibleLocalBounds)).center, size);
						if (num == 0)
						{
							val3 = val8;
						}
						else
						{
							((Bounds)(ref val3)).Encapsulate(val8);
						}
						num++;
					}
				}
				Bounds val10 = default(Bounds);
				foreach (SceneGroup group2 in SceneGroups.Values.Where((SceneGroup group) => group.HasMap()).Distinct())
				{
					foreach (CustomScene item2 in CustomScenes.Values.Where((CustomScene o) => o.Group == group2.Id))
					{
						Vector2 val9 = group2.ZoomPos + item2.MapPos;
						if (val9.x < self.panMinX)
						{
							self.panMinX = val9.x;
						}
						if (val9.x > self.panMaxX)
						{
							self.panMaxX = val9.x;
						}
						if (val9.y < self.panMinY)
						{
							self.panMinY = val9.y;
						}
						if (val9.y > self.panMaxY)
						{
							self.panMaxY = val9.y;
						}
						if (Object.op_Implicit((Object)(object)item2.Gms) && Object.op_Implicit((Object)(object)item2.Gms.fullSprite))
						{
							Bounds croppedBounds = GameMapScene.GetCroppedBounds(item2.Gms.fullSprite);
							((Bounds)(ref val10))..ctor(Vector2.op_Implicit(val9), ((Bounds)(ref croppedBounds)).extents * 1.15f);
							if (num == 0)
							{
								val3 = val10;
							}
							else
							{
								((Bounds)(ref val3)).Encapsulate(val10);
							}
							num++;
						}
					}
				}
				self.mapBounds = val3;
				Vector3 center = ((Bounds)(ref self.mapMarkerScrollArea)).center;
				ArrayForEnumAttribute.EnsureArraySize<WrappedVector2List>(ref instance.placedMarkers, typeof(MarkerTypes));
				if (!flag3)
				{
					Bounds val11 = default(Bounds);
					bool flag5 = false;
					if (Object.op_Implicit((Object)(object)self.markerParent) && (Object)(object)self.markerParent != (Object)(object)((Component)self).transform)
					{
						self.markerToGameMapLocal = ((Component)self).transform.worldToLocalMatrix * self.markerParent.localToWorldMatrix;
					}
					for (int k = 0; k < self.spawnedMapMarkers.GetLength(0); k++)
					{
						WrappedVector2List val12 = instance.placedMarkers[k];
						if (val12 == null)
						{
							WrappedVector2List[] placedMarkers = instance.placedMarkers;
							int num2 = k;
							WrappedVector2List val13 = new WrappedVector2List();
							val12 = val13;
							placedMarkers[num2] = val13;
						}
						foreach (Vector3 item3 in ((WrappedList<Vector2>)(object)val12).List.Select((Vector2 t) => ((Matrix4x4)(ref self.markerToGameMapLocal)).MultiplyPoint3x4(Vector2.op_Implicit(t))))
						{
							if (flag5)
							{
								((Bounds)(ref val11)).Encapsulate(item3);
							}
							else
							{
								val11 = new Bounds(item3, Vector3.zero);
								flag5 = true;
							}
						}
					}
					if (flag5)
					{
						((Bounds)(ref val3)).Encapsulate(val11);
					}
				}
				self.MapMarkerBounds = val3;
				self.NoPanBounds = val3;
				Bounds zoomedBounds = self.ApplyScrollAreaOffset(val3);
				((Bounds)(ref zoomedBounds)).center = -((Bounds)(ref zoomedBounds)).center + center;
				((Bounds)(ref self.MapMarkerBounds)).center = -((Bounds)(ref self.MapMarkerBounds)).center + center;
				((Bounds)(ref self.NoPanBounds)).center = -((Bounds)(ref self.NoPanBounds)).center + center;
				if (num > 1)
				{
					self.panMinX = ((Bounds)(ref zoomedBounds)).min.x;
					self.panMinY = ((Bounds)(ref zoomedBounds)).min.y;
					self.panMaxX = ((Bounds)(ref zoomedBounds)).max.x;
					self.panMaxY = ((Bounds)(ref zoomedBounds)).max.y;
				}
				else
				{
					GameMap obj2 = self;
					obj2.panMinX += center.x;
					GameMap obj3 = self;
					obj3.panMaxX += center.x;
					GameMap obj4 = self;
					obj4.panMinY += center.y;
					GameMap obj5 = self;
					obj5.panMaxY += center.y;
				}
				self.ZoomedBounds = zoomedBounds;
			});
		}

		public static void AdjustMapScale(InventoryWideMap wideMap)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			float num = 1f;
			foreach (SceneGroup item in SceneGroups.Values.Where((SceneGroup g) => g.HasMapZone && Object.op_Implicit((Object)(object)g.MapSprite)))
			{
				Vector2 val = item.MapPos * 1.34f;
				Bounds bounds = item.MapSprite.bounds;
				Vector2 val2 = val + Vector2.op_Implicit(((Bounds)(ref bounds)).max);
				Vector2 val3 = item.MapPos * 1.34f;
				bounds = item.MapSprite.bounds;
				Vector2 val4 = val3 + Vector2.op_Implicit(((Bounds)(ref bounds)).min);
				num = Mathf.Min(new float[5]
				{
					num,
					6f / Mathf.Abs(val2.y),
					6f / Mathf.Abs(val4.y),
					10f / Mathf.Abs(val2.x),
					10f / Mathf.Abs(val4.x)
				});
			}
			if (Object.op_Implicit((Object)(object)wideMap))
			{
				((Component)wideMap).transform.localScale = new Vector3(1.34f * num, 1.34f * num, 1f);
			}
			if (Object.op_Implicit((Object)(object)GameManager.instance.gameMap) && Object.op_Implicit((Object)(object)GameManager.instance.gameMap.mapManager))
			{
				GameManager.instance.gameMap.mapManager.zoneMapInitialScale = new Vector3(1.34f * num, 1.34f * num, 1f);
			}
			SceneMapStartScale.SetValue(null, (object)new Vector3(0.39f * num, 0.39f * num, 1f));
		}

		[IteratorStateMachine(typeof(<RedirectLoad>d__14))]
		private static IEnumerator RedirectLoad(Func<SceneLoad, IEnumerator> orig, SceneLoad self)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RedirectLoad>d__14(0)
			{
				orig = orig,
				self = self
			};
		}

		[IteratorStateMachine(typeof(<LoadScene>d__15))]
		public static IEnumerator LoadScene(string sceneName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadScene>d__15(0)
			{
				sceneName = sceneName
			};
		}

		public static GameObject CreateSceneManager()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_sceneManager);
			((Object)val).name = "_SceneManager";
			CustomSceneManager component = val.GetComponent<CustomSceneManager>();
			component.borderPrefab = _borderPrefab;
			component.overrideParticlesWith = (MapZone)0;
			component.noParticles = true;
			component.mapZone = (MapZone)0;
			component.environmentType = (EnvironmentTypes)5;
			component.actorSnapshot = GameManager.instance.actorSnapshotUnpaused;
			component.atmosSnapshot = AudioPlayer.AtmosSnapshot;
			component.atmosCue = NoAtmosCue;
			component.musicCue = GameManager.instance.noMusicCue;
			component.darknessLevel = 0;
			val.AddComponent<HazardRespawnMarker>();
			val.SetActive(true);
			return val;
		}

		public static GameObject CreateManager()
		{
			GameObject val = Object.Instantiate<GameObject>(_manager);
			((Object)val).name = "_Managers";
			val.SetActive(true);
			return val;
		}

		public static void CreateTileMap(CustomScene scene)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(_tilemap);
			((Object)val).name = "TileMap";
			val.SetActive(true);
			Tilemap = val.GetComponent<tk2dTileMap>();
			Tilemap.width = scene.TilemapWidth;
			Tilemap.height = scene.TilemapHeight;
			Tilemap.layers[0].width = scene.TilemapWidth;
			Tilemap.layers[0].height = scene.TilemapHeight;
			GameManager.instance.tilemap = Tilemap;
			GameManager.instance.sceneWidth = scene.TilemapWidth;
			GameManager.instance.sceneHeight = scene.TilemapHeight;
			Tilemap.layers[0].numColumns = Mathf.CeilToInt((float)scene.TilemapWidth / 32f);
			Tilemap.layers[0].numRows = Mathf.CeilToInt((float)scene.TilemapHeight / 32f);
			List<SpriteChunk> list = new List<SpriteChunk>();
			for (int i = 0; i < Tilemap.layers[0].numRows; i++)
			{
				for (int j = 0; j < Tilemap.layers[0].numColumns; j++)
				{
					list.Add(new SpriteChunk());
				}
			}
			Tilemap.layers[0].spriteChannel.chunks = list.ToArray();
			LevelData modData = MapLoader.GetModData(scene.Id);
			if (modData != null && !Extensions.IsNullOrEmpty<(int, int)>((ICollection<(int, int)>)modData.TilemapChanges))
			{
				foreach (var (num, num2) in modData.TilemapChanges)
				{
					try
					{
						if (Tilemap.GetTile(num, num2, 0) == -1)
						{
							Tilemap.SetTile(num, num2, 0, 0);
						}
						else
						{
							Tilemap.ClearTile(num, num2, 0);
						}
					}
					catch (Exception)
					{
					}
				}
			}
			LevelData levelData = PlacementManager.GetLevelData();
			if (!Extensions.IsNullOrEmpty<(int, int)>((ICollection<(int, int)>)levelData.TilemapChanges))
			{
				foreach (var (num3, num4) in levelData.TilemapChanges)
				{
					try
					{
						if (Tilemap.GetTile(num3, num4, 0) == -1)
						{
							Tilemap.SetTile(num3, num4, 0, 0);
						}
						else
						{
							Tilemap.ClearTile(num3, num4, 0);
						}
					}
					catch (Exception)
					{
					}
				}
			}
			Tilemap.Build();
		}
	}
	public static class TitleUtils
	{
		[CompilerGenerated]
		private sealed class <<Init>g__TitleDown|13_7>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

			[DebuggerHidden]
			public <<Init>g__TitleDown|13_7>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					_bigBoss.SetActive(false);
					return false;
				}
			}

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

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

		private static bool _overrideAreaText;

		private static bool _waitForCancel;

		private static int _areaType;

		private static string _areaHeader;

		private static string _areaBody;

		private static string _areaFooter;

		private static PlayMakerFSM _fsm;

		private static GameObject _bigBoss;

		private static PlayMakerFSM _bigBossFsm;

		private static FsmState _bigBossFsmUp;

		private static SetTextMeshProGameText _bigBossHeader;

		private static SetTextMeshProGameText _bigBossBody;

		private static SetTextMeshProGameText _bigBossFooter;

		public static void Init()
		{
			HookUtils.OnFsmAwake = (Action<PlayMakerFSM>)Delegate.Combine(HookUtils.OnFsmAwake, (Action<PlayMakerFSM>)delegate(PlayMakerFSM fsm)
			{
				if (fsm.FsmName == "Area Title Control")
				{
					_fsm = fsm;
					FsmString header = fsm.FsmVariables.FindFsmString("Title Sup");
					FsmString footer = fsm.FsmVariables.FindFsmString("Title Sub");
					FsmString body = fsm.FsmVariables.FindFsmString("Title Main");
					FsmBool right = fsm.FsmVariables.FindFsmBool("Display Right");
					FsmBool npc = fsm.FsmVariables.FindFsmBool("NPC Title");
					FsmFloat wait = fsm.FsmVariables.FindFsmFloat("Unvisited Wait");
					fsm.GetState("Init all").AddAction(delegate
					{
						if (_overrideAreaText)
						{
							header.value = _areaHeader;
							footer.value = _areaFooter;
							body.value = _areaBody;
							npc.value = _waitForCancel;
							wait.value = (_waitForCancel ? 9999999f : 4.75f);
						}
					}, -1, everyFrame: false);
					fsm.GetState("Visited Check").AddAction(delegate
					{
						if (_overrideAreaText)
						{
							_overrideAreaText = false;
							right.value = _areaType == 2;
							fsm.SendEvent((_areaType == 0) ? "UNVISITED" : "VISITED");
						}
					}, 0, everyFrame: false);
					fsm.GetState("Titles Down 2").AddAction(delegate
					{
						wait.value = 4.75f;
					}, 0, everyFrame: false);
				}
			});
			PreloadManager.RegisterPreload(new BasicPreload("Abyss_Cocoon", "Boss Control/Boss Title", delegate(GameObject o)
			{
				o.SetActive(false);
				_bigBoss = Object.Instantiate<GameObject>(o);
				Object.DontDestroyOnLoad((Object)(object)_bigBoss);
				_bigBossFsm = _bigBoss.GetComponent<PlayMakerFSM>();
				_bigBossFsmUp = _bigBossFsm.GetState("Title Up");
				Transform child = _bigBoss.transform.GetChild(1).GetChild(1);
				_bigBossHeader = ((Component)child.GetChild(1)).GetComponent<SetTextMeshProGameText>();
				_bigBossBody = ((Component)child.GetChild(0)).GetComponent<SetTextMeshProGameText>();
				_bigBossFooter = ((Component)child.GetChild(2)).GetComponent<SetTextMeshProGameText>();
				FsmState state = _bigBossFsm.GetState("Flash Effect");
				state.DisableAction(2);
				state.DisableAction(3);
				_bigBossFsm.GetState("Idle").AddAction(delegate
				{
					_bigBossFsm.SendEvent("TITLE UP");
				}, -1, everyFrame: false);
				_bigBossFsm.GetState("Title Down").AddAction(delegate
				{
					((MonoBehaviour)_bigBossFsm).StartCoroutine(TitleDown());
				}, -1, everyFrame: false);
			}));
			[IteratorStateMachine(typeof(<<Init>g__TitleDown|13_7>d))]
			static IEnumerator TitleDown()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<Init>g__TitleDown|13_7>d(0);
			}
		}

		public static void DisplayTitle(string header, string body, string footer, int type, bool waitForCancel = false)
		{
			if (type == 3)
			{
				DisplayBigBoss(header, body, footer, waitForCancel);
				return;
			}
			_overrideAreaText = true;
			_areaType = type;
			_areaHeader = header;
			_areaBody = body;
			_areaFooter = footer;
			_waitForCancel = waitForCancel;
			((Component)ManagerSingleton<AreaTitle>.Instance).gameObject.SetActive(true);
		}

		private static void DisplayBigBoss(string header, string body, string footer, bool waitForCancel)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			_bigBossFsmUp.actions[1].enabled = !waitForCancel;
			_bigBossHeader.Text = (LocalStr)header;
			_bigBossHeader.setTextOn.text = header;
			_bigBossBody.Text = (LocalStr)body;
			_bigBossBody.setTextOn.text = body;
			_bigBossFooter.Text = (LocalStr)footer;
			_bigBossFooter.setTextOn.text = footer;
			_bigBoss.SetActive(true);
		}

		public static void CancelTitle()
		{
			_fsm.SendEvent("FINISHED");
			_fsm.SendEvent("NPC TITLE DOWN");
			_bigBossFsm.SendEvent("FINISHED");
		}
	}
	public static class UIUtils
	{
		public class LabelledButton : MonoBehaviour
		{
			public Label label;

			private void Start()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				RectTransform component = ((Component)this).GetComponent<RectTransform>();
				component.sizeDelta = new Vector2(((Text)label.textComponent).preferredWidth * 3f + 10f, ((Text)label.textComponent).preferredHeight * 3f);
			}
		}

		public class Label : MonoBehaviour
		{
			public string font = "Perpetua";

			public TruncatableText textComponent;

			private void Start()
			{
				((Text)textComponent).font = GetFont(font);
			}

			private void Update()
			{
				if (!Object.op_Implicit((Object)(object)((Text)textComponent).font))
				{
					((Text)textComponent).font = GetFont(font);
				}
			}
		}

		public class TruncatableText : Text
		{
			public bool truncate;

			protected override void Start()
			{
				((UIBehaviour)this).Start();
				if (truncate)
				{
					Truncate();
				}
			}

			private void Update()
			{
				if (truncate)
				{
					Truncate();
				}
			}

			public void Truncate()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				while (((Graphic)this).rectTransform.sizeDelta.x < ((Text)this).preferredWidth)
				{
					string text = ((Text)this).text;
					((Text)this).text = text.Substring(0, text.Length - 4) + "...";
				}
			}
		}

		public static readonly Sprite Square = ResourceUtils.LoadSpriteResource("square", (FilterMode)1);

		public static readonly Color LightGrey = new Color(0.7f, 0.7f, 0.7f);

		private static readonly Sprite ButtonSprite = ResourceUtils.LoadSpriteResource("button_outline", new Vector2(0.5f, 0.5f), (FilterMode)1, new Vector4(6f, 5f, 6f, 5f));

		private static readonly Sprite ButtonSpriteBlank = ResourceUtils.LoadSpriteResource("button_no_outline", new Vector2(0.5f, 0.5f), (FilterMode)1, new Vector4(6f, 5f, 6f, 5f));

		private static readonly Vector2 Centre = new Vector2(0.5f, 0.5f);

		private static readonly Dictionary<string, Font> Fonts = new Dictionary<string, Font>();

		public static (Button, Image, Label) MakeButtonWithImage(string name, GameObject parent, Vector2 pos, Vector2 anchorMin, Vector2 anchorMax, int size, int imageSize, bool doOutline = true)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			Button val3 = val.AddComponent<Button>();
			Image val4 = val.AddComponent<Image>();
			ColorBlock colors = ((Selectable)val3).colors;
			((ColorBlock)(ref colors)).pressedColor = LightGrey;
			((ColorBlock)(ref colors)).disabledColor = Color.grey;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)val3).colors = colors;
			((Selectable)val3).targetGraphic = (Graphic)(object)val4;
			val4.sprite = (doOutline ? ButtonSprite : ButtonSpriteBlank);
			val4.type = (Type)1;
			((Transform)val2).SetParent(parent.transform, false);
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			val2.sizeDelta = new Vector2((float)size, (float)size);
			Transform transform = val.transform;
			transform.localScale /= 3f;
			val2.anchoredPosition = pos;
			GameObject val5 = new GameObject("Image");
			val5.transform.SetParent((Transform)(object)val2, false);
			val5.AddComponent<RectTransform>().sizeDelta = new Vector2((float)imageSize, (float)imageSize);
			Image val6 = val5.AddComponent<Image>();
			val6.preserveAspect = true;
			Label label = MakeLabel(name + " Label", val, Vector2.zero, Centre, Centre, 80f, 80f, (HorizontalWrapMode)1);
			((Text)label.textComponent).alignment = (TextAnchor)4;
			return (val3, val6, label);
		}

		public static (Button, Label) MakeTextButton(string name, string text, GameObject parent, Vector2 pos, Vector2 anchorMin, Vector2 anchorMax, bool hasOutline = true, Vector2 size = default(Vector2))
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0071: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			Button val3 = val.AddComponent<Button>();
			Label label;
			if (hasOutline)
			{
				label = MakeLabel(name + " Label", parent, pos, anchorMin, anchorMax, 80f, 80f, (HorizontalWrapMode)1);
				Image val5 = (Image)(object)(((Selectable)val3).targetGraphic = (Graphic)(object)val.AddComponent<Image>());
				val5.sprite = ButtonSprite;
				val5.type = (Type)1;
				ColorBlock colors = ((Selectable)val3).colors;
				((ColorBlock)(ref colors)).pressedColor = LightGrey;
				((ColorBlock)(ref colors)).fadeDuration = 0.1f;
				((Selectable)val3).colors = colors;
				((Text)label.textComponent).fontSize = 8;
			}
			else
			{
				label = MakeLabel(name + " Label", val, Vector2.zero, Centre, Centre, 80f, 80f, (HorizontalWrapMode)1);
				((Selectable)val3).targetGraphic = (Graphic)(object)label.textComponent;
				((Component)label).transform.SetParent((Transform)(object)val2);
				((Text)label.textComponent).fontSize = 44;
				Transform transform = ((Component)label).transform;
				transform.localScale /= 3f;
			}
			((Text)label.textComponent).alignment = (TextAnchor)4;
			((Text)label.textComponent).text = text;
			((Transform)val2).SetParent(parent.transform, false);
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			Transform transform2 = val.transform;
			transform2.localScale /= 3f;
			val2.anchoredPosition = pos;
			if (size == Vector2.zero)
			{
				val.AddComponent<LabelledButton>().label = label;
			}
			else
			{
				val2.sizeDelta = size;
			}
			return (val3, label);
		}

		public static (InputField, Label) MakeTextbox(string name, GameObject parent, Vector2 pos, Vector2 anchorMin, Vector2 anchorMax, float width, float height, int fontSize = 20)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			InputField val3 = val.AddComponent<InputField>();
			val2.sizeDelta = new Vector2(width, height);
			Label label = MakeLabel(name + " Label", parent, pos, anchorMin, anchorMax, width - 15f, 80f, (HorizontalWrapMode)1);
			Image val5 = (Image)(object)(((Selectable)val3).targetGraphic = (Graphic)(object)val.AddComponent<Image>());
			val5.sprite = ButtonSprite;
			val5.type = (Type)1;
			ColorBlock colors = ((Selectable)val3).colors;
			((ColorBlock)(ref colors)).selectedColor = LightGrey;
			((ColorBlock)(ref colors)).pressedColor = LightGrey;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)val3).colors = colors;
			val3.textComponent = (Text)(object)label.textComponent;
			val3.textComponent.supportRichText = false;
			((Text)label.textComponent).fontSize = fontSize;
			Transform transform = ((Component)label).transform;
			transform.localScale /= 3f;
			((Text)label.textComponent).alignment = (TextAnchor)3;
			((Transform)val2).SetParent(parent.transform, false);
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			Transform transform2 = val.transform;
			transform2.localScale /= 3f;
			val2.anchoredPosition = pos;
			return (val3, label);
		}

		public static Label MakeLabel(string name, GameObject parent, Vector2 pos, Vector2 anchorMin, Vector2 anchorMax, float maxWidth = 80f, float maxHeight = 80f, HorizontalWrapMode wrapMode = 1)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			Label label = val.AddComponent<Label>();
			label.textComponent = val.AddComponent<TruncatableText>();
			((Text)label.textComponent).supportRichText = false;
			((Text)label.textComponent).horizontalOverflow = wrapMode;
			((Transform)val2).SetParent(parent.transform, false);
			((Transform)val2).SetAsFirstSibling();
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			val2.sizeDelta = new Vector2(maxWidth, maxHeight);
			val2.anchoredPosition = pos;
			return label;
		}

		public static Font GetFont(string fontName)
		{
			if (Fonts.TryGetValue(fontName, out var value))
			{
				return value;
			}
			Font[] array = Resources.FindObjectsOfTypeAll<Font>();
			foreach (Font val in array)
			{
				if (((Object)val).name == fontName)
				{
					Fonts[fontName] = val;
					return val;
				}
			}
			return Fonts.GetValueOrDefault(fontName);
		}

		public static Image MakeImage(string name, GameObject parent, Vector2 pos, Vector2 anchorMin, Vector2 anchorMax, Vector2 size)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent.transform, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchoredPosition = pos;
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			val2.sizeDelta = size;
			Image val3 = val.AddComponent<Image>();
			val3.preserveAspect = false;
			Transform transform = val.transform;
			transform.localScale *= 0.5f;
			return val3;
		}

		public static (ScrollRect, GameObject, GameObject) MakeScrollView(string name, GameObject parent, Vector2 pos, Vector2 scrollbarPos, Vector2 anchorMin, Vector2 anchorMax, Vector2 size, int height)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			Image val = MakeImage(name, parent, pos, anchorMin, anchorMax, size);
			val.sprite = Square;
			((Component)val).transform.localScale = Vector3.one;
			ScrollRect val2 = ((Component)val).gameObject.AddComponent<ScrollRect>();
			val2.horizontal = false;
			val2.movementType = (MovementType)2;
			val2.decelerationRate = 1f;
			GameObject val3 = new GameObject("Viewport");
			val3.transform.SetParent(((Component)val).transform, false);
			val3.AddComponent<Mask>();
			Image val4 = val3.AddComponent<Image>();
			val4.sprite = Square;
			val3.RemoveOffset();
			((Graphic)val).color = Color.clear;
			((Graphic)val4).color = new Color(1f, 1f, 1f, 0.1f);
			GameObject val5 = new GameObject("Content");
			val5.transform.SetParent(val3.transform, false);
			val2.content = val5.RemoveOffset();
			((RectTransform)val5.transform).sizeDelta = new Vector2(0f, (float)height);
			Image val6 = MakeImage("Bar", ((Component)val).gameObject, scrollbarPos, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(50f, 750f));
			val6.sprite = Square;
			((Graphic)val6).color = Color.grey;
			Scrollbar val7 = ((Component)val6).gameObject.AddComponent<Scrollbar>();
			val7.direction = (Direction)2;
			GameObject val8 = new GameObject("Scroll Area");
			val8.transform.SetParent(((Component)val6).transform, false);
			val8.RemoveOffset();
			Image val9 = MakeImage("Handle", ((Component)val6).gameObject, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(50f, 155f));
			val9.sprite = Square;
			val7.handleRect = ((Component)val9).GetComponent<RectTransform>();
			((Selectable)val7).targetGraphic = (Graphic)(object)val9;
			val2.verticalScrollbar = val7;
			val5.AddComponent<VerticalLayoutGroup>();
			return (val2, val5, ((Component)val6).gameObject);
		}

		public static RectTransform RemoveOffset(this GameObject obj)
		{
			//IL_0009: 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_0021: 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)
			RectTransform orAddComponent = obj.GetOrAddComponent<RectTransform>();
			orAddComponent.anchorMax = Vector2.one;
			orAddComponent.anchorMin = Vector2.zero;
			orAddComponent.offsetMax = Vector2.zero;
			orAddComponent.offsetMin = Vector2.zero;
			return orAddComponent;
		}
	}
	public static class ZipUtils
	{
		private static void CopyTo(Stream src, Stream dest)
		{
			byte[] array = new byte[4096];
			int count;
			while ((count = src.Read(array, 0, array.Length)) != 0)
			{
				dest.Write(array, 0, count);
			}
		}

		public static byte[] Zip(string str)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(str);
			using MemoryStream src = new MemoryStream(bytes);
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream dest = new GZipStream(memoryStream, CompressionMode.Compress))
			{
				CopyTo(src, dest);
			}
			return memoryStream.ToArray();
		}

		public static string Unzip(byte[] bytes)
		{
			using MemoryStream stream = new MemoryStream(bytes);
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream src = new GZipStream(stream, CompressionMode.Decompress))
			{
				CopyTo(src, memoryStream);
			}
			return Encoding.UTF8.GetString(memoryStream.ToArray());
		}
	}
}
namespace Architect.Storage
{
	public static class CustomAssetManager
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public string id;

			public string url;

			internal bool <LoadSprite>b__0()
			{
				return !LoadingSprites.Contains(id);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_1
		{
			public string path;

			public <>c__DisplayClass10_0 CS$<>8__locals1;

			internal Task<bool> <LoadSprite>b__1()
			{
				return SaveFile(CS$<>8__locals1.url, path);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_0
		{
			public string url;

			internal bool <LoadSound>b__0()
			{
				return !LoadingSounds.Contains(url);
			}

			internal void <LoadSound>b__1(AudioClip clip)
			{
				if (Object.op_Implicit((Object)(object)clip))
				{
					Sounds[url] = clip;
				}
				LoadingSounds.Remove(url);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_1
		{
			public string path;

			public <>c__DisplayClass12_0 CS$<>8__locals1;

			internal Task<bool> <LoadSound>b__2()
			{
				return SaveFile(CS$<>8__locals1.url, path);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass8_0
		{
			public string url;

			public string path;

			internal Task<bool> <LoadVideo>b__0()
			{
				return SaveFile(url, path);
			}
		}

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

			private object <>2__current;

			public string url;

			public Action<AudioClip> callback;

			private <>c__DisplayClass12_0 <>8__1;

			private AudioClip <sound>5__2;

			private <>c__DisplayClass12_1 <>8__3;

			private Task<bool> <task>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<sound>5__2 = null;
				<>8__3 = null;
				<task>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass12_0();
					<>8__1.url = url;
					if (LoadingSounds.Contains(<>8__1.url))
					{
						<>2__current = (object)new WaitUntil((Func<bool>)(() => !LoadingSounds.Contains(<>8__1.url)));
						<>1__state = 1;
						return true;
					}
					if (Sounds.ContainsKey(<>8__1.url))
					{
						break;
					}
					<>8__3 = new <>c__DisplayClass12_1();
					<>8__3.CS$<>8__locals1 = <>8__1;
					LoadingSounds.Add(<>8__3.CS$<>8__locals1.url);
					<>8__3.path = GetPath(<>8__3.CS$<>8__locals1.url + ".wav");
					if (!File.Exists(<>8__3.path))
					{
						<task>5__4 = Task.Run(() => SaveFile(<>8__3.CS$<>8__locals1.url, <>8__3.path));
						goto IL_019c;
					}
					goto IL_01b8;
				case 1:
					<>1__state = -1;
					if (Sounds.TryGetValue(<>8__1.url, out <sound>5__2))
					{
						callback(<sound>5__2);
					}
					return false;
				case 2:
					<>1__state = -1;
					goto IL_019c;
				case 3:
					{
						<>1__state = -1;
						if (!Sounds.ContainsKey(<>8__3.CS$<>8__locals1.url))
						{
							return false;
						}
						<>8__3 = null;
						break;
					}
					IL_01b8:
					<>2__current = ResourceUtils.LoadClip(<>8__3.path, delegate(AudioClip clip)
					{
						if (Object.op_Implicit((Object)(object)clip))
						{
							Sounds[<>8__3.CS$<>8__locals1.url] = clip;
						}
						LoadingSounds.Remove(<>8__3.CS$<>8__locals1.url);
					});
					<>1__state = 3;
					return true;
					IL_019c:
					if (!<task>5__4.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<task>5__4 = null;
					goto IL_01b8;
				}
				callback(Sounds[<>8__1.url]);
				return false;
			}

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

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

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

			private object <>2__current;

			public string url;

			public bool point;

			public float ppu;

			public int hcount;

			public int vcount;

			public Action<Sprite[]> callback;

			private <>c__DisplayClass10_0 <>8__1;

			private Sprite[] <sprite>5__2;

			private <>c__DisplayClass10_1 <>8__3;

			private Sprite[] <tmp>5__4;

			private Task<bool> <task>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<sprite>5__2 = null;
				<>8__3 = null;
				<tmp>5__4 = null;
				<task>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass10_0();
					<>8__1.url = url;
					<>8__1.id = $"{<>8__1.url}_{point}_{ppu}_{hcount}_{vcount}";
					if (LoadingSprites.Contains(<>8__1.id))
					{
						<>2__current = (object)new WaitUntil((Func<bool>)(() => !LoadingSprites.Contains(<>8__1.id)));
						<>1__state = 1;
						return true;
					}
					if (Sprites.ContainsKey(<>8__1.id))
					{
						break;
					}
					<>8__3 = new <>c__DisplayClass10_1();
					<>8__3.CS$<>8__locals1 = <>8__1;
					LoadingSprites.Add(<>8__3.CS$<>8__locals1.id);
					<>8__3.path = GetPath(<>8__3.CS$<>8__locals1.url + ".png");
					<tmp>5__4 = ResourceUtils.LoadSprites(<>8__3.path, point, ppu, hcount, vcount);
					if (<tmp>5__4 == null)
					{
						<task>5__5 = Task.Run(() => SaveFile(<>8__3.CS$<>8__locals1.url, <>8__3.path));
						goto IL_021e;
					}
					goto IL_0268;
				case 1:
					<>1__state = -1;
					if (Sprites.TryGetValue(<>8__1.id, out <sprite>5__2))
					{
						callback(<sprite>5__2);
					}
					return false;
				case 2:
					{
						<>1__state = -1;
						goto IL_021e;
					}
					IL_0268:
					LoadingSprites.Remove(<>8__3.CS$<>8__locals1.id);
					if (<tmp>5__4 == null)
					{
						return false;
					}
					Sprites[<>8__3.CS$<>8__locals1.id] = <tmp>5__4;
					<>8__3 = null;
					<tmp>5__4 = null;
					break;
					IL_021e:
					if (!<task>5__5.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<tmp>5__4 = ResourceUtils.LoadSprites(<>8__3.path, point, ppu, hcount, vcount);
					<task>5__5 = null;
					goto IL_0268;
				}
				callback(Sprites[<>8__1.id]);
				return false;
			}

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

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

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

			private object <>2__current;

			public string url;

			public float? scale;

			public VideoPlayer player;

			private <>c__DisplayClass8_0 <>8__1;

			private Task<bool> <task>5__2;

			private float <sc>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<task>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass8_0();
					<>8__1.url = url;
					<>8__1.path = GetPath(<>8__1.url + ".mov");
					if (!File.Exists(<>8__1.path))
					{
						<task>5__2 = Task.Run(() => SaveFile(<>8__1.url, <>8__1.path));
						goto IL_00bf;
					}
					goto IL_00d9;
				case 1:
					<>1__state = -1;
					goto IL_00bf;
				case 2:
					{
						<>1__state = -1;
						goto IL_011c;
					}
					IL_00d9:
					if (!Object.op_Implicit((Object)(object)player))
					{
						break;
					}
					player.url = <>8__1.path;
					goto IL_011c;
					IL_00bf:
					if (!<task>5__2.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<task>5__2 = null;
					goto IL_00d9;
					IL_011c:
					if (player.width == 0)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<sc>5__3 = scale.GetValueOrDefault(EditManager.CurrentScale);
					Extensions.SetScaleX(((Component)player).transform, <sc>5__3 * (float)player.width / 100f);
					Extensions.SetScaleY(((Component)player).transform, <sc>5__3 * (float)player.height / 100f);
					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 static readonly Dictionary<string, Sprite[]> Sprites = new Dictionary<string, Sprite[]>();

		public static readonly Dictionary<string, AudioClip> Sounds = new Dictionary<string, AudioClip>();

		public static readonly HashSet<string> LoadingSounds = new HashSet<string>();

		public static readonly HashSet<string> LoadingSprites = new HashSet<string>();

		public static readonly List<string> AssetPaths = new List<string>();

		public static int DownloadingAssets;

		public static int Downloaded;

		public static int Failed;

		public static async Task<bool> SaveFile(string url, string path)
		{
			try
			{
				WebClient webClient = new WebClient();
				await webClient.DownloadFileTaskAsync(url, path);
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static void WipeAssets()
		{
			foreach (Sprite item in Sprites.Values.SelectMany((Sprite[] spr) => spr))
			{
				Object.Destroy((Object)(object)item);
			}
			foreach (AudioClip value in Sounds.Values)
			{
				Object.Destroy((Object)(object)value);
			}
			Sprites.Clear();
			Sounds.Clear();
		}

		public static void DoLoadVideo(VideoPlayer player, float? scale, string url)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadVideo(url, scale, player));
		}

		[IteratorStateMachine(typeof(<LoadVideo>d__8))]
		private static IEnumerator LoadVideo(string url, float? scale, [CanBeNull] VideoPlayer player = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadVideo>d__8(0)
			{
				url = url,
				scale = scale,
				player = player
			};
		}

		public static void DoLoadSprite(string url, bool point, float ppu, int hcount, int vcount, Action<Sprite[]> callback)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadSprite(url, point, ppu, Mathf.Max(1, hcount), Mathf.Max(1, vcount), callback));
		}

		[IteratorStateMachine(typeof(<LoadSprite>d__10))]
		private static IEnumerator LoadSprite(string url, bool point, float ppu, int hcount, int vcount, Action<Sprite[]> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadSprite>d__10(0)
			{
				url = url,
				point = point,
				ppu = ppu,
				hcount = hcount,
				vcount = vcount,
				callback = callback
			};
		}

		public static void DoLoadSound(string url, Action<AudioClip> callback)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadSound(url, callback));
		}

		[IteratorStateMachine(typeof(<LoadSound>d__12))]
		private static IEnumerator LoadSound(string url, Action<AudioClip> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadSound>d__12(0)
			{
				url = url,
				callback = callback
			};
		}

		private static string GetSavePath(string file)
		{
			string path = file.Aggregate(file, (string current, char c) => (char.IsLetterOrDigit(c) || c == '.') ? current : current.Replace(c, '_'));
			return Path.Combine(StorageManager.DataPath, "Assets", path);
		}

		private static string GetPath(string file)
		{
			string text = Path.GetInvalidFileNameChars().Aggregate(file, (string current, char c) => current.Replace(c, '_'));
			string text2 = file.Aggregate(file, (string current, char c) => (char.IsLetterOrDigit(c) || c == '.') ? current : current.Replace(c, '_'));
			foreach (string assetPath in AssetPaths)
			{
				string text3 = Path.Combine(assetPath, text);
				if (File.Exists(text3))
				{
					return text3;
				}
				string text4 = Path.Combine(assetPath, text2);
				if (File.Exists(text4))
				{
					return text4;
				}
			}
			string text5 = Path.Combine(StorageManager.DataPath, "Assets", text);
			return File.Exists(text5) ? text5 : Path.Combine(StorageManager.DataPath, "Assets", text2);
		}

		public static async Task TryDownloadAssets(StringConfigValue config, Text status, int downloadCount)
		{
			string fileType;
			if (config.GetTypeId().Equals("png_url"))
			{
				fileType = ".png";
			}
			else if (config.GetTypeId().Equals("wav_url"))
			{
				fileType = ".wav";
			}
			else
			{
				if (!config.GetTypeId().Equals("mp4_url"))
				{
					return;
				}
				fileType = ".mov";
			}
			string url = config.GetValue();
			bool b = await SaveFile(url, GetSavePath(url) + fileType);
			DownloadingAssets--;
			Downloaded++;
			status.text = "Downloading Assets...\n" + $"{Downloaded}/{downloadCount}";
			if (!b)
			{
				Failed++;
			}
		}

		public static async Task TryDownloadAssets(Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock> config, Text status, int downloadCount)
		{
			if (config.GetTypeId().Equals("png_url"))
			{
				string fileType = ".png";
				string url = config.GetValue();
				bool b = await SaveFile(url, GetSavePath(url) + fileType);
				DownloadingAssets--;
				Downloaded++;
				status.text = "Downloading Assets...\n" + $"{Downloaded}/{downloadCount}";
				if (!b)
				{
					Failed++;
				}
			}
		}

		public static async Task TryDownloadAssets(string url, string type, Text status, int downloadCount)
		{
			string fileType;
			if (!(type == "png"))
			{
				if (!(type == "wav"))
				{
					return;
				}
				fileType = ".wav";
			}
			else
			{
				fileType = ".png";
			}
			bool b = await SaveFile(url, GetSavePath(url) + fileType);
			DownloadingAssets--;
			Downloaded++;
			status.text = "Downloading Assets...\n" + $"{Downloaded}/{downloadCount}";
			if (!b)
			{
				Failed++;
			}
		}
	}
	public static class ProjectManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Parse<string> <>9__0_1;

			public static Unparse<string> <>9__0_2;

			public static MenuElementGenerator <>9__0_0;

			internal SelectableElement <Init>b__0_0()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Expected O, but got Unknown
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Expected O, but got Unknown
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Expected O, but got Unknown
				<>c__DisplayClass0_0 CS$<>8__locals0 = new <>c__DisplayClass0_0();
				TextButton val = new TextButton(LocalizedText.Raw("Architect Project"));
				CS$<>8__locals0.current = "";
				CS$<>8__locals0.sms = new SimpleMenuScreen("Project Manager");
				CS$<>8__locals0.te = new TextInput<string>(LocalizedText.Raw("Project To Save"), (ITextModel<string>)(object)new ParserTextModel<string>((Parse<string>)delegate(string p, out string q)
				{
					q = p;
					return true;
				}, (Unparse<string>)delegate(string p, out string q)
				{
					q = p;
					return true;
				}, CS$<>8__locals0.current));
				((SelectableValueElement<string>)(object)CS$<>8__locals0.te).OnValueChanged += delegate(string s)
				{
					CS$<>8__locals0.current = s;
				};
				CS$<>8__locals0.sms.Add((MenuElement)(object)CS$<>8__locals0.te);
				TextButton val2 = new TextButton(LocalizedText.op_Implicit("Save"));
				CS$<>8__locals0.sms.Add((MenuElement)(object)val2);
				CS$<>8__locals0.choice = new ChoiceElement<string>(LocalizedText.op_Implicit("Project To Load"), new List<string>(1) { "None" });
				CS$<>8__locals0.sms.Add((MenuElement)(object)CS$<>8__locals0.choice);
				TextButton val3 = new TextButton(LocalizedText.op_Implicit("Load"));
				CS$<>8__locals0.sms.Add((MenuElement)(object)val3);
				TextButton val4 = new TextButton(LocalizedText.op_Implicit("Delete"));
				CS$<>8__locals0.sms.Add((MenuElement)(object)val4);
				val2.OnSubmit = (Action)Delegate.Combine(val2.OnSubmit, (Action)delegate
				{
					if (!Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)CS$<>8__locals0.te).Value))
					{
						if (!GlobalArchitectData.Instance.SavedMapNames.Contains(((SelectableValueElement<string>)(object)CS$<>8__locals0.te).Value))
						{
							GlobalArchitectData.Instance.SavedMapNames.Add(((SelectableValueElement<string>)(object)CS$<>8__locals0.te).Value);
						}
						StorageManager.MakeBackup(((SelectableValueElement<string>)(object)CS$<>8__locals0.te).Value);
						StorageManager.MakeBackup(DateTime.Now.ToString("yy-MM-dd-HH-mm-ss"));
						UpdateValues();
					}
				});
				val3.OnSubmit = (Action)Delegate.Combine(val3.OnSubmit, (Action)delegate
				{
					if (!(((SelectableValueElement<string>)(object)CS$<>8__locals0.choice).Value == "None") && !Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)CS$<>8__locals0.choice).Value))
					{
						StorageManager.LoadBackup(((SelectableValueElement<string>)(object)CS$<>8__locals0.choice).Value);
					}
				});
				val4.OnSubmit = (Action)Delegate.Combine(val4.OnSubmit, (Action)delegate
				{
					if (!(((SelectableValueElement<string>)(object)CS$<>8__locals0.choice).Value == "None") && !Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)CS$<>8__locals0.choice).Value))
					{
						GlobalArchitectData.Instance.SavedMapNames.Remove(((SelectableValueElement<string>)(object)CS$<>8__locals0.choice).Value);
						StorageManager.DeleteBackup(((SelectableValueElement<string>)(object)CS$<>8__locals0.choice).Value);
						UpdateValues();
					}
				});
				val.OnSubmit = (Action)Delegate.Combine(val.OnSubmit, (Action)delegate
				{
					UpdateValues();
					MenuScreenNavigation.Show((AbstractMenuScreen)(object)CS$<>8__locals0.sms, (HistoryMode)0);
				});
				return (SelectableElement)(object)val;
				void UpdateValues()
				{
					((ListChoiceModel<string>)(object)CS$<>8__locals0.choice.ChoiceModel).UpdateValues(Extensions.IsNullOrEmpty<string>((ICollection<string>)GlobalArchitectData.Instance.SavedMapNames) ? new List<string>(1) { "None" } : GlobalArchitectData.Instance.SavedMapNames, 0);
				}
			}

			internal bool <Init>b__0_1(string p, out string q)
			{
				q = p;
				return true;
			}

			internal bool <Init>b__0_2(string p, out string q)
			{
				q = p;
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass0_0
		{
			public string current;

			public TextInput<string> te;

			public ChoiceElement<string> choice;

			public SimpleMenuScreen sms;

			internal void <Init>b__3(string s)
			{
				current = s;
			}

			internal void <Init>b__5()
			{
				if (!Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)te).Value))
				{
					if (!GlobalArchitectData.Instance.SavedMapNames.Contains(((SelectableValueElement<string>)(object)te).Value))
					{
						GlobalArchitectData.Instance.SavedMapNames.Add(((SelectableValueElement<string>)(object)te).Value);
					}
					StorageManager.MakeBackup(((SelectableValueElement<string>)(object)te).Value);
					StorageManager.MakeBackup(DateTime.Now.ToString("yy-MM-dd-HH-mm-ss"));
					UpdateValues();
				}
				void UpdateValues()
				{
					((ListChoiceModel<string>)(object)choice.ChoiceModel).UpdateValues(Extensions.IsNullOrEmpty<string>((ICollection<string>)GlobalArchitectData.Instance.SavedMapNames) ? new List<string>(1) { "None" } : GlobalArchitectData.Instance.SavedMapNames, 0);
				}
			}

			internal void <Init>b__6()
			{
				if (!(((SelectableValueElement<string>)(object)choice).Value == "None") && !Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)choice).Value))
				{
					StorageManager.LoadBackup(((SelectableValueElement<string>)(object)choice).Value);
				}
			}

			internal void <Init>b__7()
			{
				if (!(((SelectableValueElement<string>)(object)choice).Value == "None") && !Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)choice).Value))
				{
					GlobalArchitectData.Instance.SavedMapNames.Remove(((SelectableValueElement<string>)(object)choice).Value);
					StorageManager.DeleteBackup(((SelectableValueElement<string>)(object)choice).Value);
					UpdateValues();
				}
				void UpdateValues()
				{
					((ListChoiceModel<string>)(object)choice.ChoiceModel).UpdateValues(Extensions.IsNullOrEmpty<string>((ICollection<string>)GlobalArchitectData.Instance.SavedMapNames) ? new List<string>(1) { "None" } : GlobalArchitectData.Instance.SavedMapNames, 0);
				}
			}

			internal void <Init>b__8()
			{
				UpdateValues();
				MenuScreenNavigation.Show((AbstractMenuScreen)(object)sms, (HistoryMode)0);
				void UpdateValues()
				{
					((ListChoiceModel<string>)(object)choice.ChoiceModel).UpdateValues(Extensions.IsNullOrEmpty<string>((ICollection<string>)GlobalArchitectData.Instance.SavedMapNames) ? new List<string>(1) { "None" } : GlobalArchitectData.Instance.SavedMapNames, 0);
				}
			}
		}

		public static void Init()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				MenuElementGenerator val = delegate
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0017: Expected O, but got Unknown
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Expected O, but got Unknown
					//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ca: Expected O, but got Unknown
					//IL_011a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0120: Expected O, but got Unknown
					//IL_0137: Unknown result type (might be due to invalid IL or missing references)
					//IL_013e: Expected O, but got Unknown
					TextButton val2 = new TextButton(LocalizedText.Raw("Architect Project"));
					string current = "";
					SimpleMenuScreen sms = new SimpleMenuScreen("Project Manager");
					TextInput<string> te = new TextInput<string>(LocalizedText.Raw("Project To Save"), (ITextModel<string>)(object)new ParserTextModel<string>((Parse<string>)delegate(string p, out string q)
					{
						q = p;
						return true;
					}, (Unparse<string>)delegate(string p, out string q)
					{
						q = p;
						return true;
					}, current));
					((SelectableValueElement<string>)(object)te).OnValueChanged += delegate(string s)
					{
						current = s;
					};
					sms.Add((MenuElement)(object)te);
					TextButton val3 = new TextButton(LocalizedText.op_Implicit("Save"));
					sms.Add((MenuElement)(object)val3);
					ChoiceElement<string> choice = new ChoiceElement<string>(LocalizedText.op_Implicit("Project To Load"), new List<string>(1) { "None" });
					sms.Add((MenuElement)(object)choice);
					TextButton val4 = new TextButton(LocalizedText.op_Implicit("Load"));
					sms.Add((MenuElement)(object)val4);
					TextButton val5 = new TextButton(LocalizedText.op_Implicit("Delete"));
					sms.Add((MenuElement)(object)val5);
					val3.OnSubmit = (Action)Delegate.Combine(val3.OnSubmit, (Action)delegate
					{
						if (!Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)te).Value))
						{
							if (!GlobalArchitectData.Instance.SavedMapNames.Contains(((SelectableValueElement<string>)(object)te).Value))
							{
								GlobalArchitectData.Instance.SavedMapNames.Add(((SelectableValueElement<string>)(object)te).Value);
							}
							StorageManager.MakeBackup(((SelectableValueElement<string>)(object)te).Value);
							StorageManager.MakeBackup(DateTime.Now.ToString("yy-MM-dd-HH-mm-ss"));
							UpdateValues();
						}
					});
					val4.OnSubmit = (Action)Delegate.Combine(val4.OnSubmit, (Action)delegate
					{
						if (!(((SelectableValueElement<string>)(object)choice).Value == "None") && !Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)choice).Value))
						{
							StorageManager.LoadBackup(((SelectableValueElement<string>)(object)choice).Value);
						}
					});
					val5.OnSubmit = (Action)Delegate.Combine(val5.OnSubmit, (Action)delegate
					{
						if (!(((SelectableValueElement<string>)(object)choice).Value == "None") && !Utility.IsNullOrWhiteSpace(((SelectableValueElement<string>)(object)choice).Value))
						{
							GlobalArchitectData.Instance.SavedMapNames.Remove(((SelectableValueElement<string>)(object)choice).Value);
							StorageManager.DeleteBackup(((SelectableValueElement<string>)(object)choice).Value);
							UpdateValues();
						}
					});
					val2.OnSubmit = (Action)Delegate.Combine(val2.OnSubmit, (Action)delegate
					{
						UpdateValues();
						MenuScreenNavigation.Show((AbstractMenuScreen)(object)sms, (HistoryMode)0);
					});
					return (SelectableElement)(object)val2;
					void UpdateValues()
					{
						((ListChoiceModel<string>)(object)choice.ChoiceModel).UpdateValues(Extensions.IsNullOrEmpty<string>((ICollection<string>)GlobalArchitectData.Instance.SavedMapNames) ? new List<string>(1) { "None" } : GlobalArchitectData.Instance.SavedMapNames, 0);
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			Registry.AddModMenu("Architect Control", (MenuElementGenerator)obj);
		}
	}
	public static class Settings
	{
		public class Keybind
		{
			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private ConfigEntry<KeyCode> <code>P;

			public bool IsPressed => Input.GetKey(<code>P.Value);

			public bool WasPressed => Input.GetKeyDown(<code>P.Value);

			public Keybind(ConfigEntry<KeyCode> code)
			{
				<code>P = code;
				base..ctor();
			}
		}

		public static Keybind ToggleEditor;

		public static Keybind Rotate;

		public static Keybind InvertRotate;

		public static Keybind UnsafeRotation;

		public static Keybind Flip;

		public static Keybind ScaleUp;

		public static Keybind ScaleDown;

		public static Keybind SaveObject;

		public static Keybind LockAxis;

		public static Keybind Undo;

		public static Keybind Redo;

		public static Keybind MultiSelect;

		public static Keybind Copy;

		public static Keybind Paste;

		public static Keybind Preview;

		public static Keybind Overwrite;

		public static Keybind GrabId;

		public static Keybind StartLocked;

		public static Keybind StartScripted;

		public static Keybind Blank;

		public static Keybind Cursor;

		public static Keybind Drag;

		public static Keybind Eraser;

		public static Keybind Pick;

		public static Keybind Reset;

		public static Keybind Lock;

		public static Keybind TileChanger;

		public static Keybind CreateNewComment;

		public static ConfigEntry<bool> LegacyEventSystem;

		public static ConfigEntry<bool> TestMode;

		public static ConfigEntry<bool> ShowRespawnPoint;

		public static ConfigEntry<bool> BlockInventoryInEditMode;

		public static ConfigEntry<bool> LoadAllAssets;

		public static bool PrideMode;

		public static ConfigEntry<int> SaveSlot;

		public static ConfigEntry<Color> EditorBackgroundColour;

		public static ConfigEntry<Color> ScriptEditorSelectionColor;

		public static ConfigEntry<Color> ScriptEditorSelectionOutlineColor;

		public static ConfigEntry<Color> ScriptEditorBlockSelectedLerpColor;

		public static void Init(ConfigFile config)
		{
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			ToggleEditor = new Keybind(config.Bind<KeyCode>("Keybinds", "EditToggle", (KeyCode)101, "Toggles Edit Mode"));
			Rotate = new Keybind(config.Bind<KeyCode>("Keybinds", "Rotate", (KeyCode)114, "Rotates the object on the cursor"));
			InvertRotate = new Keybind(config.Bind<KeyCode>("Keybinds", "InvertRotate", (KeyCode)304, "Inverts the direction of the Rotate keybind"));
			UnsafeRotation = new Keybind(config.Bind<KeyCode>("Keybinds", "UnsafeRotation", (KeyCode)308, "Allows rotating objects at any angle"));
			Flip = new Keybind(config.Bind<KeyCode>("Keybinds", "Flip", (KeyCode)102, "Flips the object on the cursor"));
			ScaleUp = new Keybind(config.Bind<KeyCode>("Keybinds", "ScaleUp", (KeyCode)61, "Increases the scale of the object on the cursor"));
			ScaleDown = new Keybind(config.Bind<KeyCode>("Keybinds", "ScaleDown", (KeyCode)45, "Decreases the scale of the object on the cursor"));
			SaveObject = new Keybind(config.Bind<KeyCode>("Keybinds", "SaveObject", (KeyCode)13, "Saves the object on the cursor as a saved object"));
			LockAxis = new Keybind(config.Bind<KeyCode>("Keybinds", "LockAxis", (KeyCode)303, "Locks the current X or Y axis to the axis of the last placed object"));
			Undo = new Keybind(config.Bind<KeyCode>("Keybinds", "Undo", (KeyCode)122, "Undoes the last action"));
			Redo = new Keybind(config.Bind<KeyCode>("Keybinds", "Redo", (KeyCode)121, "Redoes the last action"));
			MultiSelect = new Keybind(config.Bind<KeyCode>("Keybinds", "MultiSelect", (KeyCode)306, "Allows selecting multiple objects with the Drag tool"));
			Copy = new Keybind(config.Bind<KeyCode>("Keybinds", "Copy", (KeyCode)99, "Copies the current selection of objects"));
			Paste = new Keybind(config.Bind<KeyCode>("Keybinds", "Paste", (KeyCode)118, "Pastes the objects on the clipboard"));
			Preview = new Keybind(config.Bind<KeyCode>("Keybinds", "Preview", (KeyCode)112, "Preview objects affected by the Object Anchor"));
			Overwrite = new Keybind(config.Bind<KeyCode>("Keybinds", "Overwrite", (KeyCode)111, "Overwrites a clicked object with the one on your cursor"));
			GrabId = new Keybind(config.Bind<KeyCode>("Keybinds", "GrabId", (KeyCode)105, "Sets the ID option of the object on the cursor to the selected object's ID"));
			StartLocked = new Keybind(config.Bind<KeyCode>("Keybinds", "StartLocked", (KeyCode)0, "Makes the placed object be locked instantly upon placing it"));
			StartScripted = new Keybind(config.Bind<KeyCode>("Keybinds", "StartScripted", (KeyCode)0, "Makes the placed object be added to the script instantly upon placing it"));
			Blank = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "Blank", (KeyCode)0, "Clears your current selected item"));
			Cursor = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "Cursor", (KeyCode)0, "Sets your current selected item to the Cursor tool"));
			Drag = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "Drag", (KeyCode)0, "Sets your current selected item to the Drag tool"));
			Eraser = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "Eraser", (KeyCode)0, "Sets your current selected item to the Eraser tool"));
			Pick = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "Pick", (KeyCode)0, "Sets your current selected item to the Pick tool"));
			Reset = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "Reset", (KeyCode)0, "Sets your current selected item to the Reset tool"));
			TileChanger = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "TilemapChanger", (KeyCode)0, "Sets your current selected item to the Tilemap Changer tool"));
			Lock = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "Lock", (KeyCode)0, "Locks an object in place so it cannot be edited until unlocked"));
			CreateNewComment = new Keybind(config.Bind<KeyCode>("ToolHotkeys", "CreateNewComment", (KeyCode)103, "Creates a new comment block from the selection in the script editor"));
			TestMode = config.Bind<bool>("Options", "TestMode", false, "Stops the game from storing persistent data in such as enemies being killed");
			LegacyEventSystem = config.Bind<bool>("Options", "LegacyEventSystem", false, "Enables the Legacy objects tab and the Events and Listeners tabs");
			ShowRespawnPoint = config.Bind<bool>("Options", "ShowRespawnPoint", false, "Adds an indicator showing your current hazard respawn point");
			BlockInventoryInEditMode = config.Bind<bool>("Options", "BlockInventoryInEditMode", true, "Prevents the inventory from being opened during edit mode");
			LoadAllAssets = config.Bind<bool>("Options", "LoadAllAssets", false, "Loads all assets on startup instead of when needed");
			SaveSlot = config.Bind<int>("Options", "DownloadSlot", 4, "The save slot to download save files from the level sharer into");
			EditorBackgroundColour = config.Bind<Color>("Options", "EditorBackgroundColour", new Color(0.1f, 0.1f, 0.1f), "The background colour of the script editor");
			ScriptEditorSelectionColor = config.Bind<Color>("Options", "ScriptEditorSelectionColor", new Color(0f, 0.5f, 1f, 0.12f), "The color of the selection box in the script editor");
			ScriptEditorSelectionOutlineColor = config.Bind<Color>("Options", "ScriptEditorSelectionOutlineColor", new Color(0f, 0.5f, 1f, 0.8f), "The color of the outline of the selection box in the script editor");
			ScriptEditorBlockSelectedLerpColor = config.Bind<Color>("Options", "ScriptEditorBlockSelectedLerpColor", Color.cyan, "The color thats used to lerp the color of selected blocks");
		}
	}
	public static class StorageManager
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass25_0
		{
			public Text status;

			public int downloadCount;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass25_1
		{
			public StringConfigValue config;

			public <>c__DisplayClass25_0 CS$<>8__locals1;

			internal Task <LoadLevelData>b__5()
			{
				return CustomAssetManager.TryDownloadAssets(config, CS$<>8__locals1.status, CS$<>8__locals1.downloadCount);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass25_2
		{
			public Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock> config;

			public <>c__DisplayClass25_0 CS$<>8__locals2;

			internal Task <LoadLevelData>b__6()
			{
				return CustomAssetManager.TryDownloadAssets(config, CS$<>8__locals2.status, CS$<>8__locals2.downloadCount);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass25_3
		{
			public string url;

			public string type;

			public <>c__DisplayClass25_0 CS$<>8__locals3;

			internal Task <LoadLevelData>b__7()
			{
				return CustomAssetManager.TryDownloadAssets(url, type, CS$<>8__locals3.status, CS$<>8__locals3.downloadCount);
			}
		}

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

			private object <>2__current;

			public Dictionary<string, LevelData> levels;

			public WorkshopData workshop;

			public Text status;

			private <>c__DisplayClass25_0 <>8__1;

			private float <startTime>5__2;

			private Dictionary<string, StringConfigValue> <downloads>5__3;

			private Dictionary<string, Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock>> <blockDownloads>5__4;

			private HashSet<PlaceableObject> <placeable>5__5;

			private int <cherries>5__6;

			private int <goldCherries>5__7;

			private GlobalArchitectData <gad>5__8;

			private string <levelId>5__9;

			private (List<string>, int) <score>5__10;

			private (List<string>, int) <gscore>5__11;

			private Dictionary<string, string> <workshopDownloads>5__12;

			private int <preloadCount>5__13;

			private int <doneCount>5__14;

			private float <elapsed>5__15;

			private string <plural>5__16;

			private Dictionary<string, LevelData>.Enumerator <>s__17;

			private string <scene>5__18;

			private LevelData <data>5__19;

			private IEnumerator<PreloadObject> <>s__20;

			private PreloadObject <pt>5__21;

			private IEnumerator<StringConfigValue> <>s__22;

			private StringConfigValue <config>5__23;

			private string <cfg>5__24;

			private IEnumerator<Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock>> <>s__25;

			private Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock> <config>5__26;

			private string <cfg>5__27;

			private List<WorkshopItem>.Enumerator <>s__28;

			private WorkshopItem <item>5__29;

			private Dictionary<string, Architect.Workshop.Types.ConfigValue>.ValueCollection.Enumerator <>s__30;

			private Architect.Workshop.Types.ConfigValue <cfg>5__31;

			private (string, string)[] <>s__32;

			private int <>s__33;

			private (string, string) <file>5__34;

			private Dictionary<string, StringConfigValue>.ValueCollection.Enumerator <>s__35;

			private <>c__DisplayClass25_1 <>8__36;

			private Dictionary<string, Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock>>.ValueCollection.Enumerator <>s__37;

			private <>c__DisplayClass25_2 <>8__38;

			private Dictionary<string, string>.Enumerator <>s__39;

			private <>c__DisplayClass25_3 <>8__40;

			private HashSet<PlaceableObject>.Enumerator <>s__41;

			private PlaceableObject <preload>5__42;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				case -5:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally3();
					}
					break;
				case -6:
				case 5:
					try
					{
					}
					finally
					{
						<>m__Finally4();
					}
					break;
				}
				<>8__1 = null;
				<downloads>5__3 = null;
				<blockDownloads>5__4 = null;
				<placeable>5__5 = null;
				<gad>5__8 = null;
				<levelId>5__9 = null;
				<score>5__10 = default((List<string>, int));
				<gscore>5__11 = default((List<string>, int));
				<workshopDownloads>5__12 = null;
				<plural>5__16 = null;
				<>s__17 = default(Dictionary<string, LevelData>.Enumerator);
				<scene>5__18 = null;
				<data>5__19 = null;
				<>s__20 = null;
				<pt>5__21 = null;
				<>s__22 = null;
				<config>5__23 = null;
				<cfg>5__24 = null;
				<>s__25 = null;
				<config>5__26 = null;
				<cfg>5__27 = null;
				<>s__28 = default(List<WorkshopItem>.Enumerator);
				<item>5__29 = null;
				<>s__30 = default(Dictionary<string, Architect.Workshop.Types.ConfigValue>.ValueCollection.Enumerator);
				<cfg>5__31 = null;
				<>s__32 = null;
				<file>5__34 = default((string, string));
				<>s__35 = default(Dictionary<string, StringConfigValue>.ValueCollection.Enumerator);
				<>8__36 = null;
				<>s__37 = default(Dictionary<string, Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock>>.ValueCollection.Enumerator);
				<>8__38 = null;
				<>s__39 = default(Dictionary<string, string>.Enumerator);
				<>8__40 = null;
				<>s__41 = default(HashSet<PlaceableObject>.Enumerator);
				<preload>5__42 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0b56: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b60: Expected O, but got Unknown
				try
				{
					string key;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass25_0();
						<>8__1.status = status;
						WipeLevelData();
						<startTime>5__2 = Time.realtimeSinceStartup;
						<downloads>5__3 = new Dictionary<string, StringConfigValue>();
						<blockDownloads>5__4 = new Dictionary<string, Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock>>();
						<placeable>5__5 = new HashSet<PlaceableObject>();
						<cherries>5__6 = 0;
						<goldCherries>5__7 = 0;
						<>s__17 = levels.GetEnumerator();
						try
						{
							while (<>s__17.MoveNext())
							{
								<>s__17.Current.Deconstruct(out key, out var value);
								<scene>5__18 = key;
								<data>5__19 = value;
								<>s__20 = <data>5__19.Placements.Select((ObjectPlacement placement) => placement.GetPlacementType()).OfType<PreloadObject>().GetEnumerator();
								try
								{
									while (<>s__20.MoveNext())
									{
										<pt>5__21 = <>s__20.Current;
										<placeable>5__5.Add(<pt>5__21);
										<pt>5__21 = null;
									}
								}
								finally
								{
									if (<>s__20 != null)
									{
										<>s__20.Dispose();
									}
								}
								<>s__20 = null;
								<>s__22 = <data>5__19.Placements.SelectMany((ObjectPlacement obj) => obj.Config).OfType<StringConfigValue>().GetEnumerator();
								try
								{
									while (<>s__22.MoveNext())
									{
										<config>5__23 = <>s__22.Current;
										if (<config>5__23.GetTypeId().Contains("_url"))
										{
											<cfg>5__24 = <config>5__23.GetValue();
											<downloads>5__3.TryAdd(<cfg>5__24, <config>5__23);
											<cfg>5__24 = null;
											<config>5__23 = null;
										}
									}
								}
								finally
								{
									if (<>s__22 != null)
									{
										<>s__22.Dispose();
									}
								}
								<>s__22 = null;
								<>s__25 = <data>5__19.ScriptBlocks.SelectMany((ScriptBlock obj) => obj.CurrentConfig.Values).OfType<Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock>>().GetEnumerator();
								try
								{
									while (<>s__25.MoveNext())
									{
										<config>5__26 = <>s__25.Current;
										if (<config>5__26.GetTypeId().Contains("_url"))
										{
											<cfg>5__27 = <config>5__26.GetValue();
											<blockDownloads>5__4.TryAdd(<cfg>5__27, <config>5__26);
											<cfg>5__27 = null;
											<config>5__26 = null;
										}
									}
								}
								finally
								{
									if (<>s__25 != null)
									{
										<>s__25.Dispose();
									}
								}
								<>s__25 = null;
								<cherries>5__6 += <data>5__19.Placements.Count((ObjectPlacement p) => p.ID.StartsWith("cherry_false"));
								<goldCherries>5__7 += <data>5__19.Placements.Count((ObjectPlacement p) => p.ID.StartsWith("cherry_true"));
								SaveScene(<scene>5__18, <data>5__19);
								<scene>5__18 = null;
								<data>5__19 = null;
							}
						}
						finally
						{
							((IDisposable)<>s__17).Dispose();
						}
						<>s__17 = default(Dictionary<string, LevelData>.Enumerator);
						<gad>5__8 = GlobalArchitectData.Instance;
						<levelId>5__9 = <gad>5__8.CurrentMapId;
						if (!<gad>5__8.CherryScores.TryGetValue(<levelId>5__9, out <score>5__10))
						{
							(List<string>, int) tuple2 = (<gad>5__8.CherryScores[<levelId>5__9] = (new List<string>(), <cherries>5__6));
							<score>5__10 = tuple2;
						}
						else
						{
							<score>5__10.Item2 = <cherries>5__6;
						}
						<gad>5__8.CherryScores[<levelId>5__9] = <score>5__10;
						if (!<gad>5__8.GoldCherryScores.TryGetValue(<levelId>5__9, out <gscore>5__11))
						{
							(List<string>, int) tuple4 = (<gad>5__8.GoldCherryScores[<levelId>5__9] = (new List<string>(), <goldCherries>5__7));
							<gscore>5__11 = tuple4;
						}
						else
						{
							<score>5__10.Item2 = <goldCherries>5__7;
						}
						<gad>5__8.GoldCherryScores[<levelId>5__9] = <gscore>5__11;
						<workshopDownloads>5__12 = new Dictionary<string, string>();
						<>s__28 = workshop.Items.GetEnumerator();
						try
						{
							while (<>s__28.MoveNext())
							{
								<item>5__29 = <>s__28.Current;
								<>s__30 = <item>5__29.CurrentConfig.Values.GetEnumerator();
								try
								{
									while (<>s__30.MoveNext())
									{
										<cfg>5__31 = <>s__30.Current;
										<cfg>5__31.Setup(<item>5__29);
										<cfg>5__31 = null;
									}
								}
								finally
								{
									((IDisposable)<>s__30).Dispose();
								}
								<>s__30 = default(Dictionary<string, Architect.Workshop.Types.ConfigValue>.ValueCollection.Enumerator);
								if (<item>5__29.FilesToDownload == null)
								{
									continue;
								}
								<>s__32 = <item>5__29.FilesToDownload;
								for (<>s__33 = 0; <>s__33 < <>s__32.Length; <>s__33++)
								{
									<file>5__34 = <>s__32[<>s__33];
									if (!Utility.IsNullOrWhiteSpace(<file>5__34.Item1))
									{
										<workshopDownloads>5__12.TryAdd(<file>5__34.Item1, <file>5__34.Item2);
										<file>5__34 = default((string, string));
									}
								}
								<>s__32 = null;
								<item>5__29 = null;
							}
						}
						finally
						{
							((IDisposable)<>s__28).Dispose();
						}
						<>s__28 = default(List<WorkshopItem>.Enumerator);
						CustomAssetManager.DownloadingAssets = 0;
						CustomAssetManager.Downloaded = 0;
						CustomAssetManager.Failed = 0;
						<>8__1.downloadCount = <downloads>5__3.Count + <blockDownloads>5__4.Count + <workshopDownloads>5__12.Count;
						<>8__1.status.text = "Downloading Assets...\n" + $"0/{<>8__1.downloadCount}";
						<>s__35 = <downloads>5__3.Values.GetEnumerator();
						<>1__state = -3;
						goto IL_07f8;
					case 1:
						<>1__state = -3;
						goto IL_07bf;
					case 2:
						<>1__state = -4;
						goto IL_0891;
					case 3:
						<>1__state = -5;
						goto IL_097a;
					case 4:
						<>1__state = -1;
						goto IL_09f4;
					case 5:
						<>1__state = -6;
						<doneCount>5__14++;
						<>8__1.status.text = "Loading Objects...\n" + $"{<doneCount>5__14}/{<preloadCount>5__13}";
						<preload>5__42 = null;
						goto IL_0b01;
					case 6:
						{
							<>1__state = -1;
							break;
						}
						IL_07bf:
						if (CustomAssetManager.DownloadingAssets > 4)
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
						CustomAssetManager.DownloadingAssets++;
						Task.Run(() => CustomAssetManager.TryDownloadAssets(<>8__36.config, <>8__36.CS$<>8__locals1.status, <>8__36.CS$<>8__locals1.downloadCount));
						<>8__36 = null;
						goto IL_07f8;
						IL_0891:
						if (CustomAssetManager.DownloadingAssets > 4)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						CustomAssetManager.DownloadingAssets++;
						Task.Run(() => CustomAssetManager.TryDownloadAssets(<>8__38.config, <>8__38.CS$<>8__locals2.status, <>8__38.CS$<>8__locals2.downloadCount));
						<>8__38 = null;
						goto IL_08ca;
						IL_09b3:
						if (<>s__39.MoveNext())
						{
							<>8__40 = new <>c__DisplayClass25_3();
							<>8__40.CS$<>8__locals3 = <>8__1;
							<>s__39.Current.Deconstruct(out key, out var value2);
							<>8__40.url = key;
							<>8__40.type = value2;
							goto IL_097a;
						}
						<>m__Finally3();
						<>s__39 = default(Dictionary<string, string>.Enumerator);
						goto IL_09f4;
						IL_08ca:
						if (<>s__37.MoveNext())
						{
							<>8__38 = new <>c__DisplayClass25_2();
							<>8__38.CS$<>8__locals2 = <>8__1;
							<>8__38.config = <>s__37.Current;
							goto IL_0891;
						}
						<>m__Finally2();
						<>s__37 = default(Dictionary<string, Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock>>.ValueCollection.Enumerator);
						<>s__39 = <workshopDownloads>5__12.GetEnumerator();
						<>1__state = -5;
						goto IL_09b3;
						IL_09f4:
						if (CustomAssetManager.Downloaded < <>8__1.downloadCount)
						{
							<>2__current = null;
							<>1__state = 4;
							return true;
						}
						<preloadCount>5__13 = <placeable>5__5.Count;
						<doneCount>5__14 = 0;
						<>8__1.status.text = "Loading Objects...\n" + $"0/{<preloadCount>5__13}";
						<>s__41 = <placeable>5__5.GetEnumerator();
						<>1__state = -6;
						goto IL_0b01;
						IL_097a:
						if (CustomAssetManager.DownloadingAssets > 4)
						{
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
						CustomAssetManager.DownloadingAssets++;
						Task.Run(() => CustomAssetManager.TryDownloadAssets(<>8__40.url, <>8__40.type, <>8__40.CS$<>8__locals3.status, <>8__40.CS$<>8__locals3.downloadCount));
						<>8__40 = null;
						goto IL_09b3;
						IL_0b01:
						if (<>s__41.MoveNext())
						{
							<preload>5__42 = <>s__41.Current;
							<>2__current = <preload>5__42.EnsureLoaded();
							<>1__state = 5;
							return true;
						}
						<>m__Finally4();
						<>s__41 = default(HashSet<PlaceableObject>.Enumerator);
						<elapsed>5__15 = Time.realtimeSinceStartup - <startTime>5__2;
						if (<elapsed>5__15 < 1f)
						{
							<>2__current = (object)new WaitForSeconds(1f - <elapsed>5__15);
							<>1__state = 6;
							return true;
						}
						break;
						IL_07f8:
						if (<>s__35.MoveNext())
						{
							<>8__36 = new <>c__DisplayClass25_1();
							<>8__36.CS$<>8__locals1 = <>8__1;
							<>8__36.config = <>s__35.Current;
							goto IL_07bf;
						}
						<>m__Finally1();
						<>s__35 = default(Dictionary<string, StringConfigValue>.ValueCollection.Enumerator);
						<>s__37 = <blockDownloads>5__4.Values.GetEnumerator();
						<>1__state = -4;
						goto IL_08ca;
					}
					PrefabsCategory.Prefabs = LoadPrefabs(DataPath);
					WorkshopManager.LoadWorkshop(workshop);
					SaveWorkshopData();
					<plural>5__16 = ((CustomAssetManager.Failed == 1) ? "" : "s");
					<>8__1.status.text = "Download Complete" + ((CustomAssetManager.Failed == 0) ? "" : $"\n{CustomAssetManager.Failed} asset{<plural>5__16} could not be downloaded");
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__35).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__37).Dispose();
			}

			private void <>m__Finally3()
			{
				<>1__state = -1;
				((IDisposable)<>s__39).Dispose();
			}

			private void <>m__Finally4()
			{
				<>1__state = -1;
				((IDisposable)<>s__41).Dispose();
			}

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

		public const string GLOBAL = "Global";

		internal static readonly LevelData.LevelDataConverter Ldc = new LevelData.LevelDataConverter();

		internal static readonly ObjectPlacement.ObjectPlacementConverter Opc = new ObjectPlacement.ObjectPlacementConverter();

		public static string DataPath;

		private static readonly Dictionary<string, List<IScheduledEdit>> ScheduledEdits = new Dictionary<string, List<IScheduledEdit>>();

		public static readonly List<string> Directories = new List<string>();

		public static void Init()
		{
			DataPath = Path.GetFullPath(Application.persistentDataPath + "/Architect/");
			Directory.CreateDirectory(DataPath + "Scenes/");
			Directory.CreateDirectory(DataPath + "Prefabs/");
			Directory.CreateDirectory(DataPath + "Assets/");
			Directory.CreateDirectory(DataPath + "Backups/");
			Directory.CreateDirectory(DataPath + "ModAssets/");
			typeof(GameManager).Hook("SaveGame", (Action<Action<GameManager, Action<bool>>, GameManager, Action<bool>>)delegate(Action<GameManager, Action<bool>> orig, GameManager self, Action<bool> callback)
			{
				SaveFavourites(FavouritesCategory.Favourites);
				SavePrefabs(SavedCategory.Objects);
				if (EditManager.IsEditing)
				{
					SaveScene(GameManager.instance.sceneName, PlacementManager.GetLevelData());
					SaveScene("Global", PlacementManager.GetGlobalData());
					SaveWorkshopData();
				}
				foreach (var (scene, edits) in ScheduledEdits)
				{
					ApplyScheduledEdits(scene, edits);
				}
				ScheduledEdits.Clear();
				orig(self, callback);
			}, typeof(Action<bool>));
		}

		private static string GetScenePath(string scene)
		{
			if (scene.StartsWith("Prefab_"))
			{
				return MapLoader.GetPrefab(scene) ?? (DataPath + "Prefabs/" + scene + ".architect.json");
			}
			return DataPath + "Scenes/" + scene + ".architect.json";
		}

		public static void SaveScene(string scene, LevelData level)
		{
			string scenePath = GetScenePath(scene);
			if (File.Exists(scenePath))
			{
				File.Delete(scenePath);
			}
			if (Extensions.IsNullOrEmpty<ObjectPlacement>((ICollection<ObjectPlacement>)level.Placements) && Extensions.IsNullOrEmpty<(int, int)>((ICollection<(int, int)>)level.TilemapChanges) && Extensions.IsNullOrEmpty<ScriptBlock>((ICollection<ScriptBlock>)level.ScriptBlocks) && Extensions.IsNullOrEmpty<Comment>((ICollection<Comment>)level.Comments))
			{
				if (scene.StartsWith("Prefab_"))
				{
					PrefabsCategory.Remove(scene.Replace("Prefab_", ""));
				}
				return;
			}
			if (scene.StartsWith("Prefab_"))
			{
				PrefabsCategory.Add(scene.Replace("Prefab_", ""), level);
			}
			string value = SerializeLevel(level, (Formatting)1);
			using FileStream stream = File.Create(scenePath);
			using StreamWriter streamWriter = new StreamWriter(stream);
			streamWriter.Write(value);
		}

		public static LevelData LoadScene(string scene)
		{
			if (ScheduledEdits.Remove(scene, out var value))
			{
				return ApplyScheduledEdits(scene, value);
			}
			string scenePath = GetScenePath(scene);
			return File.Exists(scenePath) ? DeserializeLevel(File.ReadAllText(scenePath)) : new LevelData(new List<ObjectPlacement>(), new List<(int, int)>(), new List<ScriptBlock>(), new List<Comment>());
		}

		public static void LoadWorkshopData()
		{
			string path = DataPath + "workshop.json";
			if (!File.Exists(path))
			{
				WorkshopManager.LoadWorkshop(new WorkshopData());
				return;
			}
			string text = File.ReadAllText(path);
			WorkshopManager.LoadWorkshop(JsonConvert.DeserializeObject<WorkshopData>(text));
		}

		public static void SaveWorkshopData()
		{
			string path = DataPath + "workshop.json";
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			File.WriteAllText(path, JsonConvert.SerializeObject((object)WorkshopManager.WorkshopData, (Formatting)1));
		}

		public static LevelData DeserializeLevel(string data)
		{
			try
			{
				return JsonConvert.DeserializeObject<LevelData>(data);
			}
			catch
			{
				return null;
			}
		}

		public static List<ObjectPlacement> DeserializePlacements(string data)
		{
			try
			{
				return JsonConvert.DeserializeObject<List<ObjectPlacement>>(data);
			}
			catch (Exception)
			{
				ArchitectPlugin.Logger.LogError((object)"Invalid saved objects file (prefabs.json), clearing saved objects");
				return new List<ObjectPlacement>();
			}
		}

		public static string SerializeLevel(LevelData level, Formatting formatting)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return JsonConvert.SerializeObject((object)level, formatting, (JsonConverter[])(object)new JsonConverter[2]
			{
				(JsonConverter)Ldc,
				(JsonConverter)Opc
			});
		}

		public static string SerializePlacements(List<ObjectPlacement> placements)
		{
			return JsonConvert.SerializeObject((object)placements, (Formatting)1, (JsonConverter[])(object)new JsonConverter[1] { (JsonConverter)Opc });
		}

		public static void SaveFavourites(List<string> favourites)
		{
			string path = DataPath + "favourites.json";
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			string value = JsonConvert.SerializeObject((object)favourites);
			using FileStream stream = File.Create(path);
			using StreamWriter streamWriter = new StreamWriter(stream);
			streamWriter.Write(value);
		}

		public static List<string> LoadFavourites()
		{
			string path = DataPath + "favourites.json";
			if (File.Exists(path))
			{
				List<string> list = JsonConvert.DeserializeObject<List<string>>(File.ReadAllText(path));
				if (list != null)
				{
					return list;
				}
			}
			return new List<string>();
		}

		public static void SavePrefabs(List<SavedObject> prefabs)
		{
			string path = DataPath + "prefabs.json";
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			string value = SerializePlacements(prefabs.Select((SavedObject obj) => obj.Placement).ToList());
			using FileStream stream = File.Create(path);
			using StreamWriter streamWriter = new StreamWriter(stream);
			streamWriter.Write(value);
		}

		public static List<SavedObject> LoadSavedObjects()
		{
			string path = DataPath + "prefabs.json";
			if (File.Exists(path))
			{
				List<ObjectPlacement> list = DeserializePlacements(File.ReadAllText(path));
				if (list != null)
				{
					return list.Select((ObjectPlacement obj) => new SavedObject(obj)).ToList();
				}
			}
			return new List<SavedObject>();
		}

		public static List<PrefabObject> LoadPrefabs(string dp)
		{
			string path = dp + "/Prefabs";
			List<PrefabObject> list = new List<PrefabObject>();
			if (Directory.Exists(path))
			{
				string[] files = Directory.GetFiles(path);
				foreach (string text in files)
				{
					if (text.EndsWith(".architect.json"))
					{
						list.Add(new PrefabObject(Path.GetFileNameWithoutExtension(text).Replace("Prefab_", "").Replace(".architect", "")));
					}
				}
			}
			return list;
		}

		public static void FindLoadRequirements()
		{
			FindLoadRequirements(DataPath);
			foreach (string directory in Directories)
			{
				FindLoadRequirements(directory);
			}
		}

		public static void FindLoadRequirements(string dp)
		{
			string[] array = new string[2] { "Scenes/", "Prefabs/" };
			foreach (string path in array)
			{
				string path2 = Path.Combine(dp, path);
				if (!Directory.Exists(path2))
				{
					continue;
				}
				string[] files = Directory.GetFiles(path2);
				foreach (string text in files)
				{
					if (!text.EndsWith(".architect.json") || text.StartsWith("."))
					{
						continue;
					}
					LevelData levelData = DeserializeLevel(File.ReadAllText(text));
					if (levelData == null)
					{
						ArchitectPlugin.Logger.LogInfo((object)("Invalid scene found at " + text));
						continue;
					}
					foreach (ObjectPlacement item in levelData.Placements.Where((ObjectPlacement o) => o != null))
					{
						if (item.GetPlacementType() is PreloadObject preloadObject)
						{
							preloadObject.ShouldLoad = true;
						}
					}
				}
			}
		}

		public static string SerializeAllScenes()
		{
			Dictionary<string, LevelData> dictionary = new Dictionary<string, LevelData>();
			string[] array = new string[2] { "Scenes/", "Prefabs/" };
			foreach (string text in array)
			{
				string[] files = Directory.GetFiles(DataPath + text);
				foreach (string path in files)
				{
					string fileName = Path.GetFileName(path);
					if (fileName.EndsWith(".architect.json"))
					{
						string text2 = fileName.Replace(".architect.json", "");
						dictionary[text2] = LoadScene(text2);
					}
				}
			}
			return JsonConvert.SerializeObject((object)dictionary, (Formatting)0, (JsonConverter[])(object)new JsonConverter[2]
			{
				(JsonConverter)Ldc,
				(JsonConverter)Opc
			});
		}

		public static void WipeLevelData()
		{
			string[] files = Directory.GetFiles(DataPath + "Scenes/");
			foreach (string path in files)
			{
				File.Delete(path);
			}
			string[] files2 = Directory.GetFiles(DataPath + "Prefabs/");
			foreach (string path2 in files2)
			{
				File.Delete(path2);
			}
			string[] files3 = Directory.GetFiles(DataPath + "Assets/");
			foreach (string path3 in files3)
			{
				File.Delete(path3);
			}
			GlobalArchitectData.Instance.CurrentMap = "";
			GlobalArchitectData.Instance.CurrentMapId = "";
			CustomAssetManager.WipeAssets();
			WorkshopManager.LoadWorkshop(new WorkshopData());
		}

		[IteratorStateMachine(typeof(<LoadLevelData>d__25))]
		public static IEnumerator LoadLevelData(Dictionary<string, LevelData> levels, WorkshopData workshop, Text status)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadLevelData>d__25(0)
			{
				levels = levels,
				workshop = workshop,
				status = status
			};
		}

		public static void MakeBackup(string backupId)
		{
			try
			{
				string text = DataPath + "Backups/" + backupId;
				if (Directory.Exists(text))
				{
					Directory.Delete(text, recursive: true);
				}
				Directory.CreateDirectory(text + "/Scenes");
				Directory.CreateDirectory(text + "/Prefabs");
				string[] files = Directory.GetFiles(DataPath + "Scenes/");
				foreach (string text2 in files)
				{
					if (text2.EndsWith(".architect.json"))
					{
						File.Copy(text2, text + "/Scenes/" + Path.GetFileName(text2));
					}
				}
				string[] files2 = Directory.GetFiles(DataPath + "Prefabs/");
				foreach (string text3 in files2)
				{
					if (text3.EndsWith(".architect.json"))
					{
						File.Copy(text3, text + "/Prefabs/" + Path.GetFileName(text3));
					}
				}
				if (File.Exists(DataPath + "workshop.json"))
				{
					File.Copy(DataPath + "workshop.json", text + "/workshop.json");
				}
			}
			catch
			{
			}
		}

		public static void DeleteBackup(string backupId)
		{
			try
			{
				string path = DataPath + "Backups/" + backupId;
				Directory.Delete(path, recursive: true);
			}
			catch
			{
			}
		}

		public static void LoadBackup(string backupId)
		{
			try
			{
				string text = DataPath + "Backups/" + backupId + "/";
				WipeLevelData();
				string[] files = Directory.GetFiles(text + "Scenes/");
				foreach (string text2 in files)
				{
					if (text2.EndsWith(".architect.json"))
					{
						File.Copy(text2, DataPath + "Scenes/" + Path.GetFileName(text2));
					}
				}
				string[] files2 = Directory.GetFiles(text + "Prefabs/");
				foreach (string text3 in files2)
				{
					if (text3.EndsWith(".architect.json"))
					{
						File.Copy(text3, DataPath + "Prefabs/" + Path.GetFileName(text3));
					}
				}
				if (File.Exists(text + "workshop.json"))
				{
					File.Copy(text + "workshop.json", DataPath + "workshop.json", overwrite: true);
				}
				PrefabsCategory.Prefabs = LoadPrefabs(DataPath);
				LoadWorkshopData();
				if (!Settings.LoadAllAssets.Value)
				{
					FindLoadRequirements();
					PreloadManager.HasPreloaded = false;
					PreloadManager.FinishPreloading();
				}
			}
			catch
			{
			}
		}

		public static void SaveApiKey([CanBeNull] string key)
		{
			string path = DataPath + "key.txt";
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			if (key == null)
			{
				return;
			}
			using FileStream stream = File.Create(path);
			using StreamWriter streamWriter = new StreamWriter(stream);
			streamWriter.Write(key);
		}

		[CanBeNull]
		public static string LoadSharerKey()
		{
			string path = DataPath + "key.txt";
			return File.Exists(path) ? File.ReadAllText(path) : null;
		}

		public static void ScheduleEdit(string scene, IScheduledEdit edit)
		{
			if (!ScheduledEdits.TryGetValue(scene, out var value))
			{
				List<IScheduledEdit> list2 = (ScheduledEdits[scene] = new List<IScheduledEdit>());
				value = list2;
			}
			value.Add(edit);
		}

		public static LevelData ApplyScheduledEdits(string scene, List<IScheduledEdit> edits)
		{
			LevelData levelData = LoadScene(scene);
			foreach (IScheduledEdit edit in edits)
			{
				edit.ExecuteScheduled(levelData);
			}
			SaveScene(scene, levelData);
			return levelData;
		}

		public static void WipeScheduledEdits(string scene)
		{
			ScheduledEdits.Remove(scene);
		}
	}
}
namespace Architect.Sharer
{
	public abstract class MenuState : MonoBehaviour
	{
		public bool started;

		public virtual MenuState ReturnState => null;

		public void Close()
		{
			((Component)this).gameObject.SetActive(false);
			OnClose();
		}

		public void Open()
		{
			((Component)this).gameObject.SetActive(true);
			((Component)SharerManager.ReturnBtn).gameObject.SetActive(Object.op_Implicit((Object)(object)ReturnState));
			SharerManager.OpenSharerBtn.SetActive(!Object.op_Implicit((Object)(object)ReturnState));
			if (!started)
			{
				started = true;
				OnStart();
			}
			OnOpen();
		}

		public virtual void OnOpen()
		{
		}

		public virtual void OnClose()
		{
		}

		public virtual void OnStart()
		{
		}
	}
	public static class RequestManager
	{
		[Serializable]
		private class AuthRequestData
		{
			public string username;

			public string password;
		}

		[Serializable]
		private class ChangeRequestData
		{
			public string key;

			public string changeType;

			public string newValue;
		}

		[Serializable]
		private class LevelTagData
		{
			public int difficulty;

			public int duration;

			public bool platforming;

			public bool multiplayer;

			public bool gauntlets;

			public bool areas;

			public bool troll;

			public bool bosses;

			public bool minigames;
		}

		public class FilterInfo
		{
			public string KeyFilter;

			public string UsernameFilter;

			public string SearchQuery;

			public List<LevelInfo.LevelDifficulty> ExcludedDifficulty = new List<LevelInfo.LevelDifficulty>();

			public List<LevelInfo.LevelDifficulty> IncludedDifficulty = new List<LevelInfo.LevelDifficulty>();

			public List<LevelInfo.LevelDuration> ExcludedDurations = new List<LevelInfo.LevelDuration>();

			public List<LevelInfo.LevelDuration> IncludedDurations = new List<LevelInfo.LevelDuration>();

			public List<LevelInfo.LevelTag> ExcludedTags = new List<LevelInfo.LevelTag>();

			public List<LevelInfo.LevelTag> IncludedTags = new List<LevelInfo.LevelTag>();

			public Browse.SortingRule SortingRule = Browse.SortingRule.Featured;

			public bool Active;

			public bool KeyMode;
		}

		[Serializable]
		public class DownloadRequestData
		{
			public string level_id;
		}

		[Serializable]
		private class DeleteRequestData
		{
			public string key;

			public string name;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass11_0
		{
			public WWWForm form;

			public TaskCompletionSource<bool> done;

			internal void <UploadLevel>b__0(byte[] bytes)
			{
				if (bytes != null)
				{
					form.AddBinaryData("save", bytes, "save.dat", "application/octet-stream");
				}
				done.SetResult(result: true);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass18_0
		{
			public TaskCompletionSource<bool> done;

			internal void <DownloadSave>b__0(bool _)
			{
				done.SetResult(result: true);
			}
		}

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

			private object <>2__current;

			public string levelId;

			public string levelName;

			public Text status;

			private string <jsonBody>5__1;

			private UnityWebRequest <request>5__2;

			private byte[] <bodyRaw>5__3;

			private UnityWebRequestAsyncOperation <operation>5__4;

			private string <json>5__5;

			private Dictionary<string, string> <result>5__6;

			private IEnumerable<KeyValuePair<string, LevelData>> <prefabs>5__7;

			private Dictionary<string, LevelData> <data>5__8;

			private WorkshopData <wData>5__9;

			private Dictionary<string, string> <response>5__10;

			private string <msg>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<jsonBody>5__1 = null;
				<request>5__2 = null;
				<bodyRaw>5__3 = null;
				<operation>5__4 = null;
				<json>5__5 = null;
				<result>5__6 = null;
				<prefabs>5__7 = null;
				<data>5__8 = null;
				<wData>5__9 = null;
				<response>5__10 = null;
				<msg>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Expected O, but got Unknown
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Expected O, but got Unknown
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					status.text = "Downloading Level...";
					<jsonBody>5__1 = JsonUtility.ToJson((object)new DownloadRequestData
					{
						level_id = levelId
					});
					<request>5__2 = new UnityWebRequest("https://cometcake575.pythonanywhere.com/download_level", "POST");
					<bodyRaw>5__3 = Encoding.UTF8.GetBytes(<jsonBody>5__1);
					<request>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__3);
					<request>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
					<request>5__2.SetRequestHeader("Content-Type", "application/json");
					<operation>5__4 = <request>5__2.SendWebRequest();
					<>2__current = <operation>5__4;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (<request>5__2.responseCode != 200)
					{
						<response>5__10 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<request>5__2.downloadHandler.text);
						<msg>5__11 = <response>5__10.GetValueOrDefault("error", "Error occured when downloading");
						status.text = <msg>5__11;
						return false;
					}
					<json>5__5 = <request>5__2.downloadHandler.text;
					<result>5__6 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<json>5__5);
					<prefabs>5__7 = from o in JsonConvert.DeserializeObject<Dictionary<string, LevelData>>(<result>5__6["level"])
						where o.Key.StartsWith("Prefab_")
						select o;
					PrefabsCategory.Prefabs = <prefabs>5__7.Select((KeyValuePair<string, LevelData> o) => new PrefabObject(o.Key.Replace("Prefab_", ""))).ToList();
					<data>5__8 = JsonConvert.DeserializeObject<Dictionary<string, LevelData>>(<result>5__6["level"]);
					<wData>5__9 = JsonConvert.DeserializeObject<WorkshopData>(<result>5__6["workshop"]);
					GlobalArchitectData.Instance.CurrentMap = levelName;
					GlobalArchitectData.Instance.CurrentMapId = levelId;
					<>2__current = StorageManager.LoadLevelData(<data>5__8, <wData>5__9, status);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					PlacementManager.InvalidateScene();
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public string levelId;

			public Text status;

			private <>c__DisplayClass18_0 <>8__1;

			private string <jsonBody>5__2;

			private UnityWebRequest <request>5__3;

			private byte[] <bodyRaw>5__4;

			private UnityWebRequestAsyncOperation <operation>5__5;

			private byte[] <data>5__6;

			private Dictionary<string, string> <response>5__7;

			private string <msg>5__8;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<jsonBody>5__2 = null;
				<request>5__3 = null;
				<bodyRaw>5__4 = null;
				<operation>5__5 = null;
				<data>5__6 = null;
				<response>5__7 = null;
				<msg>5__8 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Expected O, but got Unknown
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass18_0();
					status.text = "Downloading Save...";
					<jsonBody>5__2 = JsonUtility.ToJson((object)new DownloadRequestData
					{
						level_id = levelId
					});
					<request>5__3 = new UnityWebRequest("https://cometcake575.pythonanywhere.com/download_save", "POST");
					<bodyRaw>5__4 = Encoding.UTF8.GetBytes(<jsonBody>5__2);
					<request>5__3.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__4);
					<request>5__3.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
					<request>5__3.SetRequestHeader("Content-Type", "application/json");
					<operation>5__5 = <request>5__3.SendWebRequest();
					<>2__current = <operation>5__5;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (<request>5__3.responseCode != 200)
					{
						<response>5__7 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<request>5__3.downloadHandler.text);
						<msg>5__8 = <response>5__7.GetValueOrDefault("error", "Error occured when downloading");
						status.text = <msg>5__8;
						return false;
					}
					<data>5__6 = <request>5__3.downloadHandler.data;
					<>8__1.done = new TaskCompletionSource<bool>();
					Platform.Current.WriteSaveSlot(Settings.SaveSlot.Value, <data>5__6, (Action<bool>)delegate
					{
						<>8__1.done.SetResult(result: true);
					});
					UIManager.instance.slotFour.Prepare(GameManager.instance, true, false, false);
					<>2__current = Task.WhenAll(<>8__1.done.Task, Task.Delay(1000));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					status.text = "Download Complete";
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public UserInfo info;

			public Action<string, string, string> callback;

			private string <jsonBody>5__1;

			private UnityWebRequest <request>5__2;

			private byte[] <bodyRaw>5__3;

			private UnityWebRequestAsyncOperation <operation>5__4;

			private Dictionary<string, string> <response>5__5;

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

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

			[DebuggerHidden]
			public <GetUserInfo>d__7(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();
					}
				}
				<jsonBody>5__1 = null;
				<request>5__2 = null;
				<bodyRaw>5__3 = null;
				<operation>5__4 = null;
				<response>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Invalid comparison between Unknown and I4
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<jsonBody>5__1 = info.GetRequestJson();
						<request>5__2 = new UnityWebRequest("https://cometcake575.pythonanywhere.com/status", "POST");
						<>1__state = -3;
						<bodyRaw>5__3 = Encoding.UTF8.GetBytes(<jsonBody>5__1);
						<request>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__3);
						<request>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<request>5__2.SetRequestHeader("Content-Type", "application/json");
						<operation>5__4 = <request>5__2.SendWebRequest();
						<>2__current = <operation>5__4;
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						if ((int)<operation>5__4.webRequest.result != 1)
						{
							result = false;
						}
						else
						{
							<response>5__5 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<request>5__2.downloadHandler.text);
							if (<response>5__5.ContainsKey("error"))
							{
								result = false;
							}
							else
							{
								callback(<response>5__5["username"], <response>5__5["description"], <response>5__5["pfp"]);
								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();
			}
		}

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

			private object <>2__current;

			public string id;

			private WWWForm <form>5__1;

			private UnityWebRequest <request>5__2;

			private UnityWebRequestAsyncOperation <operation>5__3;

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

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

			[DebuggerHidden]
			public <LikeLevel>d__17(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();
					}
				}
				<form>5__1 = null;
				<request>5__2 = null;
				<operation>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<form>5__1 = new WWWForm();
						<form>5__1.AddField("level_id", id);
						<form>5__1.AddField("key", SharerKey);
						<request>5__2 = UnityWebRequest.Post("https://cometcake575.pythonanywhere.com/like", <form>5__1);
						<>1__state = -3;
						<operation>5__3 = <request>5__2.SendWebRequest();
						<>2__current = <operation>5__3;
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						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();
			}
		}

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

			private object <>2__current;

			public bool signup;

			public string user;

			public string pw;

			public Text result;

			private string <jsonBody>5__1;

			private UnityWebRequest <request>5__2;

			private byte[] <bodyRaw>5__3;

			private UnityWebRequestAsyncOperation <operation>5__4;

			private Dictionary<string, string> <response>5__5;

			private string <value>5__6;

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

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

			[DebuggerHidden]
			public <Login>d__6(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();
					}
				}
				<jsonBody>5__1 = null;
				<request>5__2 = null;
				<bodyRaw>5__3 = null;
				<operation>5__4 = null;
				<response>5__5 = null;
				<value>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Expected O, but got Unknown
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				bool flag;
				try
				{
					switch (<>1__state)
					{
					default:
						flag = false;
						break;
					case 0:
						<>1__state = -1;
						<jsonBody>5__1 = JsonUtility.ToJson((object)new AuthRequestData
						{
							username = user,
							password = pw
						});
						<request>5__2 = new UnityWebRequest("https://cometcake575.pythonanywhere.com" + (signup ? "/create" : "/login"), "POST");
						<>1__state = -3;
						<bodyRaw>5__3 = Encoding.UTF8.GetBytes(<jsonBody>5__1);
						<request>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__3);
						<request>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<request>5__2.SetRequestHeader("Content-Type", "application/json");
						<operation>5__4 = <request>5__2.SendWebRequest();
						<>2__current = <operation>5__4;
						<>1__state = 1;
						flag = true;
						break;
					case 1:
						<>1__state = -3;
						<response>5__5 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<request>5__2.downloadHandler.text);
						if (<response>5__5 == null || !<response>5__5.TryGetValue("key", out <value>5__6))
						{
							result.text = <response>5__5?.GetValueOrDefault("error", "An unknown error occured") ?? "An unknown error occured";
							flag = false;
						}
						else
						{
							SharerKey = <value>5__6;
							result.text = (signup ? "Account Created" : "Logged In");
							flag = false;
						}
						<>m__Finally1();
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return flag;
			}

			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();
			}
		}

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

			private object <>2__current;

			public FilterInfo filterInfo;

			public int resultCount;

			public int offset;

			public Action<bool, List<LevelInfo>, int> callback;

			private float <current>5__1;

			private WWWForm <form>5__2;

			private UnityWebRequest <request>5__3;

			private UnityWebRequestAsyncOperation <operation>5__4;

			private List<Dictionary<string, string>> <response>5__5;

			private Dictionary<string, string> <meta>5__6;

			private List<LevelInfo> <levelInfo>5__7;

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

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

			[DebuggerHidden]
			public <SearchLevels>d__14(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();
					}
				}
				<form>5__2 = null;
				<request>5__3 = null;
				<operation>5__4 = null;
				<response>5__5 = null;
				<meta>5__6 = null;
				<levelInfo>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<current>5__1 = Time.time;
						<form>5__2 = new WWWForm();
						<form>5__2.AddField("result_count", resultCount);
						<form>5__2.AddField("offset", offset);
						<form>5__2.AddField("game", "silksong");
						<form>5__2.AddField("key_filter", filterInfo.KeyMode.ToString());
						if (filterInfo.KeyFilter != null)
						{
							<form>5__2.AddField("key", filterInfo.KeyFilter);
						}
						<form>5__2.AddField("sorting_rule", filterInfo.SortingRule.ToString());
						<form>5__2.AddField("incl_diff", JsonConvert.SerializeObject((object)filterInfo.IncludedDifficulty));
						<form>5__2.AddField("excl_diff", JsonConvert.SerializeObject((object)filterInfo.ExcludedDifficulty));
						<form>5__2.AddField("incl_dur", JsonConvert.SerializeObject((object)filterInfo.IncludedDurations));
						<form>5__2.AddField("excl_dur", JsonConvert.SerializeObject((object)filterInfo.ExcludedDurations));
						<form>5__2.AddField("incl_tags", JsonConvert.SerializeObject((object)filterInfo.IncludedTags));
						<form>5__2.AddField("excl_tags", JsonConvert.SerializeObject((object)filterInfo.ExcludedTags));
						if (!Utility.IsNullOrWhiteSpace(filterInfo.UsernameFilter))
						{
							<form>5__2.AddField("username", filterInfo.UsernameFilter);
						}
						if (!Utility.IsNullOrWhiteSpace(filterInfo.SearchQuery))
						{
							<form>5__2.AddField("contents", filterInfo.SearchQuery);
						}
						ArchitectPlugin.Logger.LogInfo((object)$"Prepared fields {Time.time - <current>5__1}");
						<current>5__1 = Time.time;
						<request>5__3 = UnityWebRequest.Post("https://cometcake575.pythonanywhere.com/search-new", <form>5__2);
						<>1__state = -3;
						<operation>5__4 = <request>5__3.SendWebRequest();
						ArchitectPlugin.Logger.LogInfo((object)$"Sending request {Time.time - <current>5__1}");
						<current>5__1 = Time.time;
						<>2__current = <operation>5__4;
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						ArchitectPlugin.Logger.LogInfo((object)$"Received response {Time.time - <current>5__1}");
						<current>5__1 = Time.time;
						try
						{
							<response>5__5 = JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(<request>5__3.downloadHandler.text);
						}
						catch (JsonReaderException)
						{
							<response>5__5 = null;
						}
						if (<response>5__5 == null || Extensions.IsNullOrEmpty<Dictionary<string, string>>((ICollection<Dictionary<string, string>>)<response>5__5) || <response>5__5[0].ContainsKey("error"))
						{
							callback(arg1: false, null, 0);
							result = false;
						}
						else
						{
							ArchitectPlugin.Logger.LogInfo((object)$"Confirmed response {Time.time - <current>5__1}");
							<current>5__1 = Time.time;
							<meta>5__6 = <response>5__5[0];
							<response>5__5.RemoveAt(0);
							<levelInfo>5__7 = LoadLevels(<response>5__5);
							ArchitectPlugin.Logger.LogInfo((object)$"Finished parsing response {Time.time - <current>5__1}");
							callback(arg1: true, <levelInfo>5__7, int.Parse(<meta>5__6["pages"]));
							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__3 != null)
				{
					((IDisposable)<request>5__3).Dispose();
				}
			}

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

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

			private object <>2__current;

			public string changeType;

			public string newValue;

			public Action<bool> callback;

			private string <jsonBody>5__1;

			private UnityWebRequest <request>5__2;

			private byte[] <bodyRaw>5__3;

			private UnityWebRequestAsyncOperation <operation>5__4;

			private Dictionary<string, string> <response>5__5;

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

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

			[DebuggerHidden]
			public <SendChangeRequest>d__9(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();
					}
				}
				<jsonBody>5__1 = null;
				<request>5__2 = null;
				<bodyRaw>5__3 = null;
				<operation>5__4 = null;
				<response>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<jsonBody>5__1 = JsonConvert.SerializeObject((object)new ChangeRequestData
						{
							key = SharerKey,
							changeType = changeType,
							newValue = newValue
						});
						<request>5__2 = new UnityWebRequest("https://cometcake575.pythonanywhere.com/update-info", "POST");
						<>1__state = -3;
						<bodyRaw>5__3 = Encoding.UTF8.GetBytes(<jsonBody>5__1);
						<request>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__3);
						<request>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<request>5__2.SetRequestHeader("Content-Type", "application/json");
						<operation>5__4 = <request>5__2.SendWebRequest();
						<>2__current = <operation>5__4;
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						<response>5__5 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<request>5__2.downloadHandler.text);
						callback(!<response>5__5.ContainsKey("error"));
						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();
			}
		}

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

			private object <>2__current;

			public string name;

			public Action<bool> callback;

			private string <jsonBody>5__1;

			private UnityWebRequest <request>5__2;

			private byte[] <bodyRaw>5__3;

			private UnityWebRequestAsyncOperation <operation>5__4;

			private Dictionary<string, string> <response>5__5;

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

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

			[DebuggerHidden]
			public <SendDeleteRequest>d__16(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();
					}
				}
				<jsonBody>5__1 = null;
				<request>5__2 = null;
				<bodyRaw>5__3 = null;
				<operation>5__4 = null;
				<response>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Expected O, but got Unknown
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<jsonBody>5__1 = JsonUtility.ToJson((object)new DeleteRequestData
						{
							key = SharerKey,
							name = name
						});
						<request>5__2 = new UnityWebRequest("https://cometcake575.pythonanywhere.com/delete", "POST");
						<>1__state = -3;
						<bodyRaw>5__3 = Encoding.UTF8.GetBytes(<jsonBody>5__1);
						<request>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(<bodyRaw>5__3);
						<request>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<request>5__2.SetRequestHeader("Content-Type", "application/json");
						<operation>5__4 = <request>5__2.SendWebRequest();
						<>2__current = <operation>5__4;
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						<response>5__5 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<request>5__2.downloadHandler.text);
						callback(<response>5__5 != null && !<response>5__5.ContainsKey("error"));
						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();
			}
		}

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

			private object <>2__current;

			public string name;

			public string desc;

			public string iconUrl;

			public int saveNumber;

			public LevelInfo.LevelDifficulty difficulty;

			public LevelInfo.LevelDuration duration;

			public List<LevelInfo.LevelTag> tags;

			public Action<bool, string> callback;

			public string overwriteLevelId;

			public int overwriteMode;

			private <>c__DisplayClass11_0 <>8__1;

			private bool <overwriting>5__2;

			private UnityWebRequest <request>5__3;

			private UnityWebRequestAsyncOperation <operation>5__4;

			private Dictionary<string, string> <response>5__5;

			private string <value>5__6;

			private LevelTagData <tagData>5__7;

			private string <jsonData>5__8;

			private byte[] <jsonBytes>5__9;

			private string <wJsonData>5__10;

			private byte[] <wJsonBytes>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<request>5__3 = null;
				<operation>5__4 = null;
				<response>5__5 = null;
				<value>5__6 = null;
				<tagData>5__7 = null;
				<jsonData>5__8 = null;
				<jsonBytes>5__9 = null;
				<wJsonData>5__10 = null;
				<wJsonBytes>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass11_0();
						<overwriting>5__2 = overwriteLevelId != null;
						<>8__1.form = new WWWForm();
						<>8__1.form.AddField("key", SharerKey);
						<>8__1.form.AddField("game", "silksong");
						if (<overwriting>5__2)
						{
							<>8__1.form.AddField("overwrite", overwriteLevelId);
							<>8__1.form.AddField("overwrite_mode", overwriteMode);
						}
						if (!<overwriting>5__2 || overwriteMode == 0)
						{
							<>8__1.form.AddField("name", name);
							<>8__1.form.AddField("desc", desc);
							<>8__1.form.AddField("url", iconUrl);
							<tagData>5__7 = new LevelTagData
							{
								difficulty = (int)difficulty,
								duration = (int)duration,
								platforming = tags.Contains(LevelInfo.LevelTag.Platforming),
								multiplayer = tags.Contains(LevelInfo.LevelTag.Multiplayer),
								gauntlets = tags.Contains(LevelInfo.LevelTag.Gauntlets),
								areas = tags.Contains(LevelInfo.LevelTag.Areas),
								troll = tags.Contains(LevelInfo.LevelTag.Troll),
								bosses = tags.Contains(LevelInfo.LevelTag.Bosses),
								minigames = tags.Contains(LevelInfo.LevelTag.Minigames)
							};
							<>8__1.form.AddField("tags", JsonUtility.ToJson((object)<tagData>5__7));
							<tagData>5__7 = null;
						}
						if (!<overwriting>5__2 || overwriteMode == 1)
						{
							<jsonData>5__8 = StorageManager.SerializeAllScenes();
							<jsonBytes>5__9 = Encoding.UTF8.GetBytes(<jsonData>5__8);
							<>8__1.form.AddBinaryData("level", <jsonBytes>5__9, "level.json", "application/json");
							<wJsonData>5__10 = JsonConvert.SerializeObject((object)WorkshopManager.WorkshopData);
							<wJsonBytes>5__11 = Encoding.UTF8.GetBytes(<wJsonData>5__10);
							<>8__1.form.AddBinaryData("workshop", <wJsonBytes>5__11, "workshop.json", "application/json");
							<jsonData>5__8 = null;
							<jsonBytes>5__9 = null;
							<wJsonData>5__10 = null;
							<wJsonBytes>5__11 = null;
						}
						<>8__1.done = new TaskCompletionSource<bool>();
						if ((!<overwriting>5__2 || overwriteMode == 2) && Platform.IsSaveSlotIndexValid(saveNumber))
						{
							Platform.Current.ReadSaveSlot(saveNumber, (Action<byte[]>)delegate(byte[] bytes)
							{
								if (bytes != null)
								{
									<>8__1.form.AddBinaryData("save", bytes, "save.dat", "application/octet-stream");
								}
								<>8__1.done.SetResult(result: true);
							});
							<>2__current = <>8__1.done.Task;
							<>1__state = 1;
							result = true;
							break;
						}
						goto IL_0366;
					case 1:
						<>1__state = -1;
						goto IL_0366;
					case 2:
						{
							<>1__state = -3;
							try
							{
								<response>5__5 = JsonConvert.DeserializeObject<Dictionary<string, string>>(<request>5__3.downloadHandler.text);
							}
							catch (JsonReaderException)
							{
								<response>5__5 = null;
							}
							<value>5__6 = null;
							if (<response>5__5 == null || <response>5__5.TryGetValue("error", out <value>5__6))
							{
								callback(arg1: false, <value>5__6 ?? "An unknown error occured");
								result = false;
							}
							else
							{
								callback(arg1: true, <response>5__5["message"]);
								result = false;
							}
							<>m__Finally1();
							break;
						}
						IL_0366:
						<request>5__3 = UnityWebRequest.Post("https://cometcake575.pythonanywhere.com/upload", <>8__1.form);
						<>1__state = -3;
						<operation>5__4 = <request>5__3.SendWebRequest();
						<>2__current = <operation>5__4;
						<>1__state = 2;
						result = true;
						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__3 != null)
				{
					((IDisposable)<request>5__3).Dispose();
				}
			}

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

		public const string URL = "https://cometcake575.pythonanywhere.com";

		public const string LEVEL_TYPE = "silksong";

		[CanBeNull]
		private static string _sharerKey = StorageManager.LoadSharerKey();

		[CanBeNull]
		public static string SharerKey
		{
			get
			{
				return _sharerKey;
			}
			set
			{
				StorageManager.SaveApiKey(value);
				_sharerKey = value;
			}
		}

		[IteratorStateMachine(typeof(<Login>d__6))]
		public static IEnumerator Login(bool signup, string user, string pw, Text result)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Login>d__6(0)
			{
				signup = signup,
				user = user,
				pw = pw,
				result = result
			};
		}

		[IteratorStateMachine(typeof(<GetUserInfo>d__7))]
		public static IEnumerator GetUserInfo(UserInfo info, Action<string, string, string> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetUserInfo>d__7(0)
			{
				info = info,
				callback = callback
			};
		}

		[IteratorStateMachine(typeof(<SendChangeRequest>d__9))]
		public static IEnumerator SendChangeRequest(string changeType, string newValue, Action<bool> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendChangeRequest>d__9(0)
			{
				changeType = changeType,
				newValue = newValue,
				callback = callback
			};
		}

		[IteratorStateMachine(typeof(<UploadLevel>d__11))]
		public static IEnumerator UploadLevel(string name, string desc, string iconUrl, int saveNumber, LevelInfo.LevelDifficulty difficulty, LevelInfo.LevelDuration duration, List<LevelInfo.LevelTag> tags, Action<bool, string> callback, [CanBeNull] string overwriteLevelId, int overwriteMode)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UploadLevel>d__11(0)
			{
				name = name,
				desc = desc,
				iconUrl = iconUrl,
				saveNumber = saveNumber,
				difficulty = difficulty,
				duration = duration,
				tags = tags,
				callback = callback,
				overwriteLevelId = overwriteLevelId,
				overwriteMode = overwriteMode
			};
		}

		private static List<LevelInfo> LoadLevels(List<Dictionary<string, string>> levelData)
		{
			List<LevelInfo> list = new List<LevelInfo>();
			foreach (Dictionary<string, string> levelDatum in levelData)
			{
				LevelInfo levelInfo = new LevelInfo
				{
					LevelId = levelDatum["level_id"],
					LevelName = levelDatum["level_name"],
					LevelDesc = levelDatum["level_desc"],
					IconURL = levelDatum["icon_url"],
					HasSave = bool.Parse(levelDatum["has_save"]),
					CreatorName = levelDatum["username"],
					CreatorId = levelDatum["user_id"],
					DownloadCount = int.Parse(levelDatum["downloads"]),
					LikeCount = int.Parse(levelDatum["likes"]),
					Liked = bool.Parse(levelDatum["liked"]),
					Uploaded = (Utility.IsNullOrWhiteSpace(levelDatum["uploaded"]) ? "Pre 2026-03-17" : levelDatum["uploaded"]),
					Updated = (Utility.IsNullOrWhiteSpace(levelDatum["updated"]) ? "Pre 2026-03-17" : levelDatum["updated"])
				};
				if (levelDatum.TryGetValue("difficulty", out var value))
				{
					LevelInfo levelInfo2 = levelInfo;
					if (1 == 0)
					{
					}
					LevelInfo.LevelDifficulty difficulty = value switch
					{
						"0" => LevelInfo.LevelDifficulty.None, 
						"1" => LevelInfo.LevelDifficulty.Easy, 
						"2" => LevelInfo.LevelDifficulty.Medium, 
						"3" => LevelInfo.LevelDifficulty.Hard, 
						"4" => LevelInfo.LevelDifficulty.ExtraHard, 
						_ => throw new ArgumentOutOfRangeException(), 
					};
					if (1 == 0)
					{
					}
					levelInfo2.Difficulty = difficulty;
					LevelInfo levelInfo3 = levelInfo;
					string text = levelDatum["duration"];
					if (1 == 0)
					{
					}
					LevelInfo.LevelDuration duration = text switch
					{
						"0" => LevelInfo.LevelDuration.Tiny, 
						"1" => LevelInfo.LevelDuration.Short, 
						"2" => LevelInfo.LevelDuration.Medium, 
						"3" => LevelInfo.LevelDuration.Long, 
						"4" => LevelInfo.LevelDuration.None, 
						_ => throw new ArgumentOutOfRangeException(), 
					};
					if (1 == 0)
					{
					}
					levelInfo3.Duration = duration;
					if (levelDatum["platforming"] == "1")
					{
						levelInfo.Tags.Add(LevelInfo.LevelTag.Platforming);
					}
					if (levelDatum["minigames"] == "1")
					{
						levelInfo.Tags.Add(LevelInfo.LevelTag.Minigames);
					}
					if (levelDatum["multiplayer"] == "1")
					{
						levelInfo.Tags.Add(LevelInfo.LevelTag.Multiplayer);
					}
					if (levelDatum["gauntlets"] == "1")
					{
						levelInfo.Tags.Add(LevelInfo.LevelTag.Gauntlets);
					}
					if (levelDatum["areas"] == "1")
					{
						levelInfo.Tags.Add(LevelInfo.LevelTag.Areas);
					}
					if (levelDatum["troll"] == "1")
					{
						levelInfo.Tags.Add(LevelInfo.LevelTag.Troll);
					}
					if (levelDatum["bosses"] == "1")
					{
						levelInfo.Tags.Add(LevelInfo.LevelTag.Bosses);
					}
				}
				list.Add(levelInfo);
			}
			return list;
		}

		[IteratorStateMachine(typeof(<SearchLevels>d__14))]
		public static IEnumerator SearchLevels(FilterInfo filterInfo, int resultCount, int offset, Action<bool, List<LevelInfo>, int> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SearchLevels>d__14(0)
			{
				filterInfo = filterInfo,
				resultCount = resultCount,
				offset = offset,
				callback = callback
			};
		}

		[IteratorStateMachine(typeof(<SendDeleteRequest>d__16))]
		public static IEnumerator SendDeleteRequest(string name, Action<bool> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendDeleteRequest>d__16(0)
			{
				name = name,
				callback = callback
			};
		}

		[IteratorStateMachine(typeof(<LikeLevel>d__17))]
		public static IEnumerator LikeLevel(string id)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LikeLevel>d__17(0)
			{
				id = id
			};
		}

		[IteratorStateMachine(typeof(<DownloadSave>d__18))]
		public static IEnumerator DownloadSave(string levelId, Text status)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DownloadSave>d__18(0)
			{
				levelId = levelId,
				status = status
			};
		}

		[IteratorStateMachine(typeof(<DownloadLevel>d__19))]
		internal static IEnumerator DownloadLevel(string levelId, string levelName, Text status)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DownloadLevel>d__19(0)
			{
				levelId = levelId,
				levelName = levelName,
				status = status
			};
		}
	}
	public static class SharerManager
	{
		private class EraseBtn : MonoBehaviour, IPointerDownHandler, IEventSystemHandler
		{
			public Action OnClick;

			public void OnPointerDown(PointerEventData eventData)
			{
				OnClick();
			}
		}

		public class SpriteURL : MonoBehaviour
		{
		}

		[CompilerGenerated]
		private sealed class <<SetupToggleBtn>g__FadeGameTitle|14_1>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private SpriteRenderer <sprite>5__1;

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

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

			[DebuggerHidden]
			public <<SetupToggleBtn>g__FadeGameTitle|14_1>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<sprite>5__1 = _uiManager.gameTitle;
					goto IL_00cd;
				case 1:
					<>1__state = -1;
					goto IL_00cd;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_00cd:
					if ((double)<sprite>5__1.color.a > 0.0 && _sharerOpen)
					{
						<sprite>5__1.color = new Color(<sprite>5__1.color.r, <sprite>5__1.color.g, <sprite>5__1.color.b, <sprite>5__1.color.a - Time.unscaledDeltaTime * 6.4f);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<sprite>5__1.color = new Color(<sprite>5__1.color.r, <sprite>5__1.color.g, <sprite>5__1.color.b, (float)((!_sharerOpen) ? 1 : 0));
					if (_sharerOpen)
					{
						_states.SetActive(true);
						EraseEditsBtn.SetActive(false);
						TransitionToState(HomeState);
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <>c__DisplayClass16_0
		{
			private sealed class <<SetupResetBtn>g__DoErase|0>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public <>c__DisplayClass16_0 <>4__this;

				private float <time>5__1;

				private float <t>5__2;

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

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

				[DebuggerHidden]
				public <<SetupResetBtn>g__DoErase|0>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<time>5__1 = Time.time;
						break;
					case 1:
						<>1__state = -1;
						if (!Input.GetMouseButton(0))
						{
							<>4__this.eraseImg.sprite = <>4__this.eraseAll;
							return false;
						}
						<t>5__2 = Time.time - <time>5__1;
						<>4__this.eraseImg.sprite = ((<t>5__2 > 2f) ? <>4__this.eraseAll1 : ((<t>5__2 > 1f) ? <>4__this.eraseAll2 : <>4__this.eraseAll3));
						break;
					}
					if (Time.time - <time>5__1 < 3f)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>4__this.eraseImg.sprite = <>4__this.eraseAll;
					StorageManager.WipeLevelData();
					PlacementManager.InvalidateScene();
					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 Image eraseImg;

			public Sprite eraseAll;

			public Sprite eraseAll1;

			public Sprite eraseAll2;

			public Sprite eraseAll3;

			internal void <SetupResetBtn>b__1()
			{
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(DoErase());
				[IteratorStateMachine(typeof(<<SetupResetBtn>g__DoErase|0>d))]
				IEnumerator DoErase()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<SetupResetBtn>g__DoErase|0>d(0)
					{
						<>4__this = this
					};
				}
			}
		}

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

			private object <>2__current;

			public string url;

			public Image apply;

			private UnityWebRequest <www>5__1;

			private Texture2D <tex>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<www>5__1 = null;
				<tex>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Invalid comparison between Unknown and I4
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					apply.sprite = ArchitectPlugin.BlankSprite;
					<www>5__1 = UnityWebRequestTexture.GetTexture(url);
					<www>5__1.timeout = 30;
					<>2__current = <www>5__1.SendWebRequest();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((int)<www>5__1.result == 1)
					{
						<tex>5__2 = DownloadHandlerTexture.GetContent(<www>5__1);
						if (((Texture)<tex>5__2).width < 1 || ((Texture)<tex>5__2).height < 1)
						{
							apply.sprite = Placeholder;
						}
						else
						{
							apply.sprite = Sprite.Create(<tex>5__2, new Rect(0f, 0f, (float)((Texture)<tex>5__2).width, (float)((Texture)<tex>5__2).height), default(Vector2));
						}
						<tex>5__2 = null;
					}
					else
					{
						apply.sprite = Placeholder;
					}
					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 static GameObject OpenSharerBtn;

		public static GameObject EraseEditsBtn;

		public static Button ReturnBtn;

		private static bool _sharerOpen;

		private static GameObject _sharer;

		private static GameObject _states;

		private static MenuState _currentMenuState;

		public static MenuState HomeState;

		private static UIManager _uiManager;

		public static readonly Sprite Placeholder = ResourceUtils.LoadSpriteResource("Sharer.placeholder", (FilterMode)0);

		public static void Init()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			_sharer = new GameObject("[Architect] Level Sharer");
			_sharer.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_sharer);
			_sharer.AddComponent<Canvas>().renderMode = (RenderMode)0;
			CanvasScaler val = _sharer.AddComponent<CanvasScaler>();
			val.uiScaleMode = (ScaleMode)1;
			val.screenMatchMode = (ScreenMatchMode)1;
			_sharer.AddComponent<GraphicRaycaster>();
			_states = new GameObject("States");
			_states.SetActive(false);
			_states.RemoveOffset();
			_states.transform.SetParent(_sharer.transform, true);
			Image val2 = UIUtils.MakeImage("Background", _states, Vector2.op_Implicit(Vector3.zero), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(3000f, 3000f));
			val2.sprite = ResourceUtils.LoadSpriteResource("Sharer.bg", (FilterMode)1);
			SetupToggleBtn();
			SetupReturnBtn();
			SetupResetBtn();
			HomeState = SetupMenuState<Home>("Home");
		}

		public static void Update()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)_uiManager))
			{
				_uiManager = Object.FindAnyObjectByType<UIManager>();
				if (!Object.op_Implicit((Object)(object)_uiManager))
				{
					return;
				}
			}
			_sharer.SetActive((int)_uiManager.menuState == 1 && PreloadManager.HasPreloaded);
		}

		public static void TransitionToState(MenuState state)
		{
			if (Object.op_Implicit((Object)(object)_currentMenuState))
			{
				_currentMenuState.Close();
			}
			state.Open();
			_currentMenuState = state;
		}

		public static MenuState SetupMenuState<T>(string name) where T : MenuState
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.RemoveOffset();
			val.transform.SetParent(_states.transform, false);
			val.SetActive(false);
			return val.AddComponent<T>();
		}

		private static void SetupToggleBtn()
		{
			//IL_0010: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			Sprite openEditor = ResourceUtils.LoadSpriteResource("Sharer.open", (FilterMode)1);
			Sprite closeEditor = ResourceUtils.LoadSpriteResource("Sharer.close", (FilterMode)1);
			(Button, Image, UIUtils.Label) tuple = UIUtils.MakeButtonWithImage("Toggle Sharer UI", _sharer, Vector2.op_Implicit(new Vector3(-50f, -50f)), new Vector2(1f, 1f), new Vector2(1f, 1f), 220, 220);
			Button item = tuple.Item1;
			Image img = tuple.Item2;
			OpenSharerBtn = ((Component)item).gameObject;
			img.sprite = openEditor;
			((UnityEvent)item.onClick).AddListener(new UnityAction(ToggleSharer));
			[IteratorStateMachine(typeof(<<SetupToggleBtn>g__FadeGameTitle|14_1>d))]
			static IEnumerator FadeGameTitle()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<SetupToggleBtn>g__FadeGameTitle|14_1>d(0);
			}
			void ToggleSharer()
			{
				_sharerOpen = !_sharerOpen;
				if (_sharerOpen)
				{
					img.sprite = closeEditor;
					((MonoBehaviour)_uiManager).StartCoroutine(FadeGameTitle());
					((MonoBehaviour)_uiManager).StartCoroutine(_uiManager.FadeOutCanvasGroup(_uiManager.mainMenuScreen, true, false));
				}
				else
				{
					img.sprite = openEditor;
					_states.SetActive(false);
					EraseEditsBtn.SetActive(true);
					_uiManager.UIGoToMainMenu();
				}
			}
		}

		private static void SetupReturnBtn()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			Sprite sprite = ResourceUtils.LoadSpriteResource("Sharer.return", (FilterMode)0);
			(Button, Image, UIUtils.Label) tuple = UIUtils.MakeButtonWithImage("Return", _sharer, Vector2.op_Implicit(new Vector3(-50f, -50f)), new Vector2(1f, 1f), new Vector2(1f, 1f), 220, 220);
			Button item = tuple.Item1;
			Image item2 = tuple.Item2;
			ReturnBtn = item;
			((Component)ReturnBtn).gameObject.SetActive(false);
			item2.sprite = sprite;
			((UnityEvent)item.onClick).AddListener(new UnityAction(GoToReturnState));
			static void GoToReturnState()
			{
				if (Object.op_Implicit((Object)(object)_currentMenuState) && Object.op_Implicit((Object)(object)_currentMenuState.ReturnState))
				{
					TransitionToState(_currentMenuState.ReturnState);
				}
			}
		}

		private static void SetupResetBtn()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			<>c__DisplayClass16_0 CS$<>8__locals0 = new <>c__DisplayClass16_0();
			(Button, Image, UIUtils.Label) tuple = UIUtils.MakeButtonWithImage("Erase Edits", _sharer, Vector2.op_Implicit(new Vector3(-50f, -140f)), new Vector2(1f, 1f), new Vector2(1f, 1f), 220, 220);
			Button item = tuple.Item1;
			CS$<>8__locals0.eraseImg = tuple.Item2;
			CS$<>8__locals0.eraseAll = ResourceUtils.LoadSpriteResource("erase_all", (FilterMode)1);
			CS$<>8__locals0.eraseAll3 = ResourceUtils.LoadSpriteResource("erase_all_3", (FilterMode)1);
			CS$<>8__locals0.eraseAll2 = ResourceUtils.LoadSpriteResource("erase_all_2", (FilterMode)1);
			CS$<>8__locals0.eraseAll1 = ResourceUtils.LoadSpriteResource("erase_all_1", (FilterMode)1);
			EraseEditsBtn = ((Component)item).gameObject;
			CS$<>8__locals0.eraseImg.sprite = CS$<>8__locals0.eraseAll;
			EraseBtn eraseBtn = ((Component)item).gameObject.AddComponent<EraseBtn>();
			eraseBtn.OnClick = (Action)Delegate.Combine(eraseBtn.OnClick, (Action)delegate
			{
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(DoErase());
			});
			[IteratorStateMachine(typeof(<>c__DisplayClass16_0.<<SetupResetBtn>g__DoErase|0>d))]
			IEnumerator DoErase()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass16_0.<<SetupResetBtn>g__DoErase|0>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		public static void DoGetSprite(string url, Image apply)
		{
			SpriteURL orAddComponent = ((Component)apply).gameObject.GetOrAddComponent<SpriteURL>();
			((MonoBehaviour)orAddComponent).StopAllCoroutines();
			((MonoBehaviour)orAddComponent).StartCoroutine(GetSprite(url, apply));
		}

		[IteratorStateMachine(typeof(<GetSprite>d__20))]
		private static IEnumerator GetSprite(string url, Image apply)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetSprite>d__20(0)
			{
				url = url,
				apply = apply
			};
		}
	}
}
namespace Architect.Sharer.States
{
	public class Account : MenuState
	{
		public abstract class OpenConfig : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			protected abstract string Title { get; }

			protected abstract string Id { get; }

			protected abstract string Current { get; }

			protected abstract int MaxLength { get; }

			protected abstract bool IsBig { get; }

			public void OnPointerClick(PointerEventData eventData)
			{
				Instance.ShowOptionType(Title, Id, Current, MaxLength, IsBig);
			}
		}

		public class UserConfig : OpenConfig
		{
			protected override string Title => "Change Username:";

			protected override string Id => "username";

			protected override string Current => CurrentUserInfo.Username;

			protected override int MaxLength => 20;

			protected override bool IsBig => false;
		}

		public class DescConfig : OpenConfig
		{
			protected override string Title => "Change About Me:";

			protected override string Id => "description";

			protected override string Current => CurrentUserInfo.Description;

			protected override int MaxLength => 1000;

			protected override bool IsBig => true;
		}

		public class PfpConfig : OpenConfig
		{
			protected override string Title => "Change Icon:";

			protected override string Id => "icon_url";

			protected override string Current => CurrentUserInfo.PfpUrl;

			protected override int MaxLength => 1000;

			protected override bool IsBig => false;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__SignOut;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass22_0
		{
			private sealed class <<SetupConfigUI>g__OnComplete|2>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public bool b;

				public <>c__DisplayClass22_0 <>4__this;

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

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

				[DebuggerHidden]
				public <<SetupConfigUI>g__OnComplete|2>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (b)
						{
							<>2__current = <>4__this.<>4__this.SetToMainUser();
							<>1__state = 1;
							return true;
						}
						break;
					case 1:
						<>1__state = -1;
						break;
					}
					((Selectable)<>4__this.cancel).interactable = true;
					((Selectable)<>4__this.confirm).interactable = true;
					<>4__this.<>4__this._configUI.SetActive(false);
					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 Account <>4__this;

			public Button cancel;

			public Button confirm;

			public Action<bool> <>9__3;

			internal void <SetupConfigUI>b__0()
			{
				<>4__this._configUI.SetActive(false);
			}

			internal void <SetupConfigUI>b__1()
			{
				((Selectable)cancel).interactable = false;
				((Selectable)confirm).interactable = false;
				((MonoBehaviour)<>4__this).StartCoroutine(RequestManager.SendChangeRequest(<>4__this._changeType, <>4__this._changeField.text, delegate(bool b)
				{
					((MonoBehaviour)<>4__this).StartCoroutine(OnComplete(b));
				}));
				[IteratorStateMachine(typeof(<<SetupConfigUI>g__OnComplete|2>d))]
				IEnumerator OnComplete(bool b)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<SetupConfigUI>g__OnComplete|2>d(0)
					{
						<>4__this = this,
						b = b
					};
				}
			}

			internal void <SetupConfigUI>b__3(bool b)
			{
				((MonoBehaviour)<>4__this).StartCoroutine(OnComplete(b));
				[IteratorStateMachine(typeof(<<SetupConfigUI>g__OnComplete|2>d))]
				IEnumerator OnComplete(bool b)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<SetupConfigUI>g__OnComplete|2>d(0)
					{
						<>4__this = this,
						b = b
					};
				}
			}
		}

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					CurrentUserInfo = new UserInfo(RequestManager.SharerKey, usingToken: true);
					<>2__current = CurrentUserInfo.Setup();
					<>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();
			}
		}

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

			private object <>2__current;

			public Account <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (RequestManager.SharerKey == null)
					{
						SharerManager.TransitionToState(<>4__this.ReturnState);
						CurrentUserInfo = null;
						return false;
					}
					<>4__this._username.text = "";
					<>4__this._desc.text = "";
					<>4__this._pfp.sprite = ArchitectPlugin.BlankSprite;
					<>2__current = PrepareUserInfo();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!CurrentUserInfo.IsSetup)
					{
						return false;
					}
					<>4__this._username.text = CurrentUserInfo.Username;
					<>4__this._desc.text = CurrentUserInfo.Description;
					SharerManager.DoGetSprite(CurrentUserInfo.PfpUrl, <>4__this._pfp);
					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 static Account Instance;

		public static UserInfo CurrentUserInfo;

		private Text _username;

		private Text _desc;

		private Image _pfp;

		private GameObject _configUI;

		private Text _changeTitle;

		private InputField _changeField;

		private RectTransform _changeLabel;

		private string _changeType;

		private Transform _bg;

		public override MenuState ReturnState => SharerManager.HomeState;

		public override void OnStart()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: 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_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Expected O, but got Unknown
			Instance = this;
			UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Username Title", ((Component)this).gameObject, new Vector2(0f, 150f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 400f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent).text = "Username:";
			((Text)textComponent).fontSize = 22;
			((Text)textComponent).alignment = (TextAnchor)0;
			((Component)textComponent).gameObject.AddComponent<UserConfig>();
			UIUtils.TruncatableText textComponent2 = UIUtils.MakeLabel("Desc Title", ((Component)this).gameObject, new Vector2(0f, 50f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 400f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent2).text = "About Me:";
			((Text)textComponent2).fontSize = 22;
			((Text)textComponent2).alignment = (TextAnchor)0;
			((Component)textComponent2).gameObject.AddComponent<DescConfig>();
			_username = (Text)(object)UIUtils.MakeLabel("Username", ((Component)this).gameObject, new Vector2(20f, 120f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 400f, 80f, (HorizontalWrapMode)1).textComponent;
			_username.fontSize = 16;
			_username.alignment = (TextAnchor)0;
			((Component)_username).gameObject.AddComponent<UserConfig>();
			_desc = (Text)(object)UIUtils.MakeLabel("Desc", ((Component)this).gameObject, new Vector2(20f, -40f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 400f, 200f, (HorizontalWrapMode)1).textComponent;
			_desc.fontSize = 16;
			_desc.alignment = (TextAnchor)0;
			_desc.horizontalOverflow = (HorizontalWrapMode)0;
			((Component)_desc).gameObject.AddComponent<DescConfig>();
			_pfp = UIUtils.MakeImage("Profile Picture", ((Component)this).gameObject, new Vector2(170f, 130f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 200f));
			((Component)_pfp).gameObject.AddComponent<PfpConfig>();
			var (val, label) = UIUtils.MakeTextButton("Sign Out", "Sign Out", ((Component)this).gameObject, new Vector2(0f, -180f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label.textComponent).fontSize = 20;
			((Text)label.textComponent).horizontalOverflow = (HorizontalWrapMode)0;
			ButtonClickedEvent onClick = val.onClick;
			object obj = <>O.<0>__SignOut;
			if (obj == null)
			{
				UnityAction val2 = SignOut;
				<>O.<0>__SignOut = val2;
				obj = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			SetupConfigUI();
		}

		public override void OnOpen()
		{
			((MonoBehaviour)this).StartCoroutine(SetToMainUser());
			_configUI.SetActive(false);
		}

		[IteratorStateMachine(typeof(<SetToMainUser>d__9))]
		public IEnumerator SetToMainUser()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetToMainUser>d__9(0)
			{
				<>4__this = this
			};
		}

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

		private static void SignOut()
		{
			RequestManager.SharerKey = null;
			SharerManager.TransitionToState(SharerManager.HomeState);
		}

		private void SetupConfigUI()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: 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_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Expected O, but got Unknown
			<>c__DisplayClass22_0 CS$<>8__locals0 = new <>c__DisplayClass22_0();
			CS$<>8__locals0.<>4__this = this;
			_configUI = new GameObject("Config UI");
			_configUI.transform.SetParent(((Component)this).gameObject.transform, false);
			_configUI.RemoveOffset();
			Image val = UIUtils.MakeImage("Bg", _configUI, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(10000f, 10000f));
			val.sprite = ResourceUtils.LoadSpriteResource("Sharer.config_bg", (FilterMode)1);
			_bg = ((Component)val).transform;
			GameObject val2 = new GameObject("Content");
			val2.transform.SetParent(_configUI.transform, false);
			val2.RemoveOffset();
			UIUtils.Label label;
			(_changeField, label) = UIUtils.MakeTextbox("Change", val2, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 1000f, 80f);
			((Component)label).transform.localScale = Vector3.one;
			((Text)label.textComponent).fontSize = 16;
			_changeLabel = (RectTransform)((Component)label).transform;
			RectTransform changeLabel = _changeLabel;
			changeLabel.sizeDelta /= 3f;
			_changeTitle = (Text)(object)UIUtils.MakeLabel("Type", val2, new Vector2(0f, 140f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_changeTitle.fontSize = 20;
			_changeTitle.alignment = (TextAnchor)4;
			UIUtils.Label label2;
			(CS$<>8__locals0.cancel, label2) = UIUtils.MakeTextButton("Cancel", "Cancel", val2, new Vector2(-70f, -140f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(360f, 80f));
			((Text)label2.textComponent).fontSize = 18;
			((UnityEvent)CS$<>8__locals0.cancel.onClick).AddListener((UnityAction)delegate
			{
				CS$<>8__locals0.<>4__this._configUI.SetActive(false);
			});
			UIUtils.Label label3;
			(CS$<>8__locals0.confirm, label3) = UIUtils.MakeTextButton("Confirm", "Confirm", val2, new Vector2(70f, -140f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(360f, 80f));
			((Text)label3.textComponent).fontSize = 18;
			((UnityEvent)CS$<>8__locals0.confirm.onClick).AddListener((UnityAction)delegate
			{
				((Selectable)CS$<>8__locals0.cancel).interactable = false;
				((Selectable)CS$<>8__locals0.confirm).interactable = false;
				((MonoBehaviour)CS$<>8__locals0.<>4__this).StartCoroutine(RequestManager.SendChangeRequest(CS$<>8__locals0.<>4__this._changeType, CS$<>8__locals0.<>4__this._changeField.text, delegate(bool b)
				{
					((MonoBehaviour)CS$<>8__locals0.<>4__this).StartCoroutine(OnComplete(b));
				}));
			});
			[IteratorStateMachine(typeof(<>c__DisplayClass22_0.<<SetupConfigUI>g__OnComplete|2>d))]
			IEnumerator OnComplete(bool b)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass22_0.<<SetupConfigUI>g__OnComplete|2>d(0)
				{
					<>4__this = CS$<>8__locals0,
					b = b
				};
			}
		}

		private void ShowOptionType(string changeTitle, string changeType, string current, int maxLength, bool isBig)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			_changeField.characterLimit = maxLength;
			((RectTransform)((Component)_changeField).transform).sizeDelta = new Vector2(1000f, (float)(isBig ? 620 : 80));
			_changeLabel.sizeDelta = new Vector2(325f, (float)(isBig ? 200 : 26));
			_changeField.lineType = (LineType)(isBig ? 2 : 0);
			_changeField.textComponent.alignment = (TextAnchor)((!isBig) ? 3 : 0);
			_changeTitle.text = changeTitle;
			_changeField.text = current;
			_changeType = changeType;
			_configUI.SetActive(true);
			_bg.SetAsFirstSibling();
		}
	}
	public class Browse : MenuState
	{
		public class ListingInstance : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler, IPointerClickHandler
		{
			public LevelInfo Info;

			public GameObject selected;

			public void OnPointerEnter(PointerEventData eventData)
			{
				if (Info != null)
				{
					selected.SetActive(true);
				}
			}

			public void OnPointerExit(PointerEventData eventData)
			{
				selected.SetActive(false);
			}

			public void OnPointerClick(PointerEventData eventData)
			{
				if (Info != null)
				{
					selected.SetActive(false);
					Instance.OpenLevel(Info);
				}
			}
		}

		public class Listing
		{
			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private ListingInstance <instance>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Text <title>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Text <desc>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Image <icon>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Text <likes>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Text <downloads>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private GameObject <downloadIcon>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Image <likeIcon>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private GameObject <likeBtn>P;

			public LevelInfo Info;

			public Listing(ListingInstance instance, Text title, Text desc, Image icon, Text likes, Text downloads, GameObject downloadIcon, Image likeIcon, GameObject likeBtn)
			{
				<instance>P = instance;
				<title>P = title;
				<desc>P = desc;
				<icon>P = icon;
				<likes>P = likes;
				<downloads>P = downloads;
				<downloadIcon>P = downloadIcon;
				<likeIcon>P = likeIcon;
				<likeBtn>P = likeBtn;
				base..ctor();
			}

			public void Setup(LevelInfo info)
			{
				Info = info;
				<instance>P.selected.SetActive(false);
				<instance>P.Info = info;
				if (info == null)
				{
					<title>P.text = "";
					<desc>P.text = "";
					<icon>P.sprite = ArchitectPlugin.BlankSprite;
					<likes>P.text = "";
					<downloads>P.text = "";
					<downloadIcon>P.SetActive(false);
					((Component)<likeIcon>P).gameObject.SetActive(false);
					<likeBtn>P.SetActive(false);
					SharerManager.SpriteURL component = ((Component)<icon>P).GetComponent<SharerManager.SpriteURL>();
					if (Object.op_Implicit((Object)(object)component))
					{
						((MonoBehaviour)component).StopAllCoroutines();
					}
				}
				else
				{
					<title>P.text = info.LevelName + " – " + info.CreatorName;
					<desc>P.text = info.LevelDesc;
					SharerManager.DoGetSprite(info.IconURL, <icon>P);
					<likes>P.text = info.LikeCount.ToString();
					<downloads>P.text = info.DownloadCount.ToString();
					<downloadIcon>P.SetActive(true);
					((Component)<likeIcon>P).gameObject.SetActive(true);
					<likeBtn>P.SetActive(true);
					<likeIcon>P.sprite = (info.Liked ? Like : BlankLike);
				}
			}
		}

		public enum SortingRule
		{
			Featured,
			Liked,
			Downloaded,
			New
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass44_0
		{
			private sealed class <<SetupLevelInfoZone>g__DownloadLevel|4>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public <>c__DisplayClass44_0 <>4__this;

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

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

				[DebuggerHidden]
				public <<SetupLevelInfoZone>g__DownloadLevel|4>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						((Text)<>4__this.downloadLabel.textComponent).text = "Cancel Download";
						((Selectable)<>4__this.<>4__this._downloadSBtn).interactable = false;
						((Selectable)<>4__this.closeBtn).interactable = false;
						((Selectable)SharerManager.ReturnBtn).interactable = false;
						<>2__current = RequestManager.DownloadLevel(<>4__this.<>4__this._info.LevelId, <>4__this.<>4__this._info.LevelName, <>4__this.<>4__this._status);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						((Selectable)<>4__this.closeBtn).interactable = true;
						if (<>4__this.<>4__this._info.HasSave)
						{
							((Selectable)<>4__this.<>4__this._downloadSBtn).interactable = true;
						}
						((Selectable)SharerManager.ReturnBtn).interactable = true;
						((Text)<>4__this.downloadLabel.textComponent).text = "Download Level";
						<>4__this.download = null;
						return false;
					}
				}

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

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

			private sealed class <<SetupLevelInfoZone>g__DownloadSave|3>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public <>c__DisplayClass44_0 <>4__this;

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

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

				[DebuggerHidden]
				public <<SetupLevelInfoZone>g__DownloadSave|3>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						((Selectable)<>4__this.downloadBtn).interactable = false;
						((Selectable)<>4__this.<>4__this._downloadSBtn).interactable = false;
						((Selectable)<>4__this.closeBtn).interactable = false;
						((Selectable)SharerManager.ReturnBtn).interactable = false;
						<>2__current = RequestManager.DownloadSave(<>4__this.<>4__this._info.LevelId, <>4__this.<>4__this._status);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						((Selectable)<>4__this.closeBtn).interactable = true;
						((Selectable)<>4__this.downloadBtn).interactable = true;
						((Selectable)<>4__this.<>4__this._downloadSBtn).interactable = true;
						((Selectable)SharerManager.ReturnBtn).interactable = true;
						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 Browse <>4__this;

			public IEnumerator download;

			public Button downloadBtn;

			public Button closeBtn;

			public UIUtils.Label downloadLabel;

			internal void <SetupLevelInfoZone>b__0()
			{
				<>4__this._level.SetActive(false);
				<>4__this._browse.SetActive(true);
			}

			internal void <SetupLevelInfoZone>b__1()
			{
				((MonoBehaviour)<>4__this).StartCoroutine(DownloadSave());
				[IteratorStateMachine(typeof(<<SetupLevelInfoZone>g__DownloadSave|3>d))]
				IEnumerator DownloadSave()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<SetupLevelInfoZone>g__DownloadSave|3>d(0)
					{
						<>4__this = this
					};
				}
			}

			internal void <SetupLevelInfoZone>b__2()
			{
				if (download == null)
				{
					download = DownloadLevel();
					((MonoBehaviour)<>4__this).StartCoroutine(download);
				}
				else
				{
					CancelDownload();
				}
				void CancelDownload()
				{
					((Text)downloadLabel.textComponent).text = "Download Level";
					((MonoBehaviour)<>4__this).StopCoroutine(download);
					((Selectable)closeBtn).interactable = true;
					if (<>4__this._info.HasSave)
					{
						((Selectable)<>4__this._downloadSBtn).interactable = true;
					}
					((Selectable)SharerManager.ReturnBtn).interactable = true;
					((Text)downloadLabel.textComponent).text = "Download Level";
					download = null;
				}
				[IteratorStateMachine(typeof(<<SetupLevelInfoZone>g__DownloadLevel|4>d))]
				IEnumerator DownloadLevel()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<SetupLevelInfoZone>g__DownloadLevel|4>d(0)
					{
						<>4__this = this
					};
				}
			}
		}

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

			private object <>2__current;

			public Browse <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this._scrollRect.verticalNormalizedPosition = 1f;
					<>4__this._filterInfo.KeyFilter = RequestManager.SharerKey;
					<>2__current = RequestManager.SearchLevels(<>4__this._filterInfo, 15, <>4__this.page, delegate(bool success, List<LevelInfo> levels, int pages)
					{
						if (!success)
						{
							SharerManager.TransitionToState(SharerManager.HomeState);
						}
						else
						{
							int i = 0;
							foreach (LevelInfo level in levels)
							{
								<>4__this._listings[i].Setup(level);
								i++;
							}
							for (; i < <>4__this._listings.Count; i++)
							{
								<>4__this._listings[i].Setup(null);
							}
							<>4__this.totalPages = pages;
							<>4__this._pageCounter.text = $"{<>4__this.page + 1}/{<>4__this.totalPages + 1}";
						}
					});
					<>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();
			}
		}

		public static Browse Instance;

		public int page;

		public int totalPages;

		private Text _pageCounter;

		private readonly List<Listing> _listings = new List<Listing>();

		private ScrollRect _scrollRect;

		private RequestManager.FilterInfo _filterInfo = new RequestManager.FilterInfo();

		private GameObject _browse;

		private GameObject _level;

		private GameObject _filter;

		private readonly List<Button> _filterBtns = new List<Button>();

		private Dictionary<LevelInfo.LevelDuration, Button> _durationButtons = new Dictionary<LevelInfo.LevelDuration, Button>();

		private Dictionary<LevelInfo.LevelDifficulty, Button> _difficultyButtons = new Dictionary<LevelInfo.LevelDifficulty, Button>();

		private Dictionary<LevelInfo.LevelTag, Button> _tagButtons = new Dictionary<LevelInfo.LevelTag, Button>();

		private InputField _searchField;

		private InputField _usernameField;

		private static readonly ColorBlock Active;

		private static readonly ColorBlock ActiveGreen;

		private static readonly ColorBlock ActiveRed;

		private static readonly ColorBlock Inactive;

		private SortingRule _currentRule = SortingRule.Featured;

		private Button _featuredBtn;

		private Button _likedBtn;

		private Button _downloadedBtn;

		private Button _newBtn;

		private Button _filterBtn;

		private LevelInfo _info;

		private Text _title;

		private Text _desc;

		private Text _tags;

		private Text _times;

		private Image _img;

		private Text _userTitle;

		private Text _userDesc;

		private Image _userImg;

		private Button _downloadSBtn;

		private Text _status;

		private static readonly Sprite BlankLike;

		private static readonly Sprite Like;

		public override MenuState ReturnState => SharerManager.HomeState;

		private void Start()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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)
			//IL_0136: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Expected O, but got Unknown
			//IL_01e5: 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_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Expected O, but got Unknown
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: 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_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			_browse = new GameObject("Browse");
			_browse.transform.SetParent(((Component)this).transform, false);
			_browse.RemoveOffset();
			_filter = new GameObject("Filter");
			_filter.transform.SetParent(((Component)this).transform, false);
			_filter.RemoveOffset();
			_level = new GameObject("Level");
			_level.transform.SetParent(((Component)this).transform, false);
			_level.RemoveOffset();
			UIUtils.Label label;
			(_featuredBtn, label) = UIUtils.MakeTextButton("Most Recent Likes", "Featured", _browse, new Vector2(-275f, 220f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(390f, 100f));
			((Text)label.textComponent).fontSize = 18;
			((UnityEvent)_featuredBtn.onClick).AddListener((UnityAction)delegate
			{
				SetSortingRule(SortingRule.Featured);
			});
			UIUtils.Label label2;
			(_likedBtn, label2) = UIUtils.MakeTextButton("Liked", "Most Liked", _browse, new Vector2(-125f, 220f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(390f, 100f));
			((Text)label2.textComponent).fontSize = 18;
			((UnityEvent)_likedBtn.onClick).AddListener((UnityAction)delegate
			{
				SetSortingRule(SortingRule.Liked);
			});
			UIUtils.Label label3;
			(_downloadedBtn, label3) = UIUtils.MakeTextButton("Downloaded", "Most Downloaded", _browse, new Vector2(25f, 220f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(390f, 100f));
			((Text)label3.textComponent).fontSize = 18;
			((UnityEvent)_downloadedBtn.onClick).AddListener((UnityAction)delegate
			{
				SetSortingRule(SortingRule.Downloaded);
			});
			UIUtils.Label label4;
			(_newBtn, label4) = UIUtils.MakeTextButton("New", "New Levels", _browse, new Vector2(175f, 220f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(390f, 100f));
			((Text)label4.textComponent).fontSize = 18;
			((UnityEvent)_newBtn.onClick).AddListener((UnityAction)delegate
			{
				SetSortingRule(SortingRule.New);
			});
			Image val;
			(_filterBtn, val, _) = UIUtils.MakeButtonWithImage("Filter", _browse, new Vector2(278f, 220f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 100, 80);
			((UnityEvent)_filterBtn.onClick).AddListener((UnityAction)delegate
			{
				_browse.SetActive(false);
				_filter.SetActive(true);
			});
			val.sprite = ResourceUtils.LoadSpriteResource("Sharer.filter", (FilterMode)1);
			SetupLevelZone();
			SetupFilterZone();
			SetupLevelInfoZone();
			RefreshButtons();
			DoSearch();
		}

		public override void OnOpen()
		{
			if (Object.op_Implicit((Object)(object)_featuredBtn))
			{
				_currentRule = SortingRule.Featured;
				WipeFilters();
			}
		}

		private void SetSortingRule(SortingRule rule)
		{
			page = 0;
			_currentRule = rule;
			_filterInfo.SortingRule = rule;
			RefreshButtons();
			DoSearch();
		}

		private void WipeFilters()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			_filterInfo = new RequestManager.FilterInfo
			{
				KeyFilter = RequestManager.SharerKey
			};
			_browse.SetActive(true);
			_filter.SetActive(false);
			_level.SetActive(false);
			foreach (Button filterBtn in _filterBtns)
			{
				((Selectable)filterBtn).colors = Inactive;
			}
			_searchField.text = "";
			_usernameField.text = "";
			RefreshButtons();
			DoSearch();
		}

		private void RefreshButtons()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			((Selectable)_featuredBtn).colors = ((_currentRule == SortingRule.Featured) ? Active : Inactive);
			((Selectable)_likedBtn).colors = ((_currentRule == SortingRule.Liked) ? Active : Inactive);
			((Selectable)_downloadedBtn).colors = ((_currentRule == SortingRule.Downloaded) ? Active : Inactive);
			((Selectable)_newBtn).colors = ((_currentRule == SortingRule.New) ? Active : Inactive);
			((Selectable)_filterBtn).colors = (_filterInfo.Active ? Active : Inactive);
		}

		private void SetupLevelInfoZone()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Expected O, but got Unknown
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_057d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Expected O, but got Unknown
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Expected O, but got Unknown
			<>c__DisplayClass44_0 CS$<>8__locals0 = new <>c__DisplayClass44_0();
			CS$<>8__locals0.<>4__this = this;
			_title = (Text)(object)UIUtils.MakeLabel("Title", _level, new Vector2(-195f, 125f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_title.fontSize = 20;
			_title.alignment = (TextAnchor)1;
			_desc = (Text)(object)UIUtils.MakeLabel("Desc", _level, new Vector2(-195f, 55f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 300f, 160f, (HorizontalWrapMode)1).textComponent;
			_desc.fontSize = 15;
			_desc.horizontalOverflow = (HorizontalWrapMode)0;
			_desc.alignment = (TextAnchor)1;
			_tags = (Text)(object)UIUtils.MakeLabel("Tags", _level, new Vector2(-85f, -130f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 290f, 160f, (HorizontalWrapMode)1).textComponent;
			_tags.fontSize = 15;
			_tags.alignment = (TextAnchor)0;
			_times = (Text)(object)UIUtils.MakeLabel("Times", _level, new Vector2(85f, -130f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 290f, 160f, (HorizontalWrapMode)1).textComponent;
			_times.fontSize = 15;
			_times.alignment = (TextAnchor)2;
			_img = UIUtils.MakeImage("Icon", _level, new Vector2(-195f, 230f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 200f));
			_img.preserveAspect = true;
			_userTitle = (Text)(object)UIUtils.MakeLabel("Title", _level, new Vector2(195f, 125f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_userTitle.fontSize = 20;
			_userTitle.alignment = (TextAnchor)1;
			_userDesc = (Text)(object)UIUtils.MakeLabel("Desc", _level, new Vector2(195f, 55f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 300f, 160f, (HorizontalWrapMode)1).textComponent;
			_userDesc.fontSize = 15;
			_userDesc.horizontalOverflow = (HorizontalWrapMode)0;
			_userDesc.alignment = (TextAnchor)1;
			_userImg = UIUtils.MakeImage("Icon", _level, new Vector2(195f, 230f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 200f));
			_userImg.preserveAspect = true;
			UIUtils.Label label;
			(CS$<>8__locals0.closeBtn, label) = UIUtils.MakeTextButton("Close", "Close", _level, new Vector2(-160f, -240f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label.textComponent).fontSize = 18;
			((UnityEvent)CS$<>8__locals0.closeBtn.onClick).AddListener((UnityAction)delegate
			{
				CS$<>8__locals0.<>4__this._level.SetActive(false);
				CS$<>8__locals0.<>4__this._browse.SetActive(true);
			});
			(CS$<>8__locals0.downloadBtn, CS$<>8__locals0.downloadLabel) = UIUtils.MakeTextButton("Download Level", "Download Level", _level, new Vector2(0f, -240f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)CS$<>8__locals0.downloadLabel.textComponent).fontSize = 18;
			UIUtils.Label label2;
			(_downloadSBtn, label2) = UIUtils.MakeTextButton("Download Save", "Download Save", _level, new Vector2(160f, -240f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label2.textComponent).fontSize = 18;
			_status = (Text)(object)UIUtils.MakeLabel("Status", _level, new Vector2(0f, -280f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_status.fontSize = 15;
			_status.alignment = (TextAnchor)4;
			((UnityEvent)_downloadSBtn.onClick).AddListener((UnityAction)delegate
			{
				((MonoBehaviour)CS$<>8__locals0.<>4__this).StartCoroutine(DownloadSave());
			});
			CS$<>8__locals0.download = null;
			((UnityEvent)CS$<>8__locals0.downloadBtn.onClick).AddListener((UnityAction)delegate
			{
				if (CS$<>8__locals0.download == null)
				{
					CS$<>8__locals0.download = DownloadLevel();
					((MonoBehaviour)CS$<>8__locals0.<>4__this).StartCoroutine(CS$<>8__locals0.download);
				}
				else
				{
					CancelDownload();
				}
			});
			_level.SetActive(false);
			void CancelDownload()
			{
				((Text)CS$<>8__locals0.downloadLabel.textComponent).text = "Download Level";
				((MonoBehaviour)CS$<>8__locals0.<>4__this).StopCoroutine(CS$<>8__locals0.download);
				((Selectable)CS$<>8__locals0.closeBtn).interactable = true;
				if (CS$<>8__locals0.<>4__this._info.HasSave)
				{
					((Selectable)CS$<>8__locals0.<>4__this._downloadSBtn).interactable = true;
				}
				((Selectable)SharerManager.ReturnBtn).interactable = true;
				((Text)CS$<>8__locals0.downloadLabel.textComponent).text = "Download Level";
				CS$<>8__locals0.download = null;
			}
			[IteratorStateMachine(typeof(<>c__DisplayClass44_0.<<SetupLevelInfoZone>g__DownloadLevel|4>d))]
			IEnumerator DownloadLevel()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass44_0.<<SetupLevelInfoZone>g__DownloadLevel|4>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
			[IteratorStateMachine(typeof(<>c__DisplayClass44_0.<<SetupLevelInfoZone>g__DownloadSave|3>d))]
			IEnumerator DownloadSave()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass44_0.<<SetupLevelInfoZone>g__DownloadSave|3>d(0)
				{
					<>4__this = CS$<>8__locals0
				};
			}
		}

		private void OpenLevel(LevelInfo info)
		{
			_info = info;
			_browse.SetActive(false);
			_level.SetActive(true);
			_title.text = info.LevelName;
			_desc.text = info.LevelDesc;
			((Selectable)_downloadSBtn).interactable = info.HasSave;
			string text = "";
			if (Extensions.IsNullOrEmpty<LevelInfo.LevelTag>((ICollection<LevelInfo.LevelTag>)info.Tags))
			{
				text = "None";
			}
			for (int i = 0; i < info.Tags.Count; i++)
			{
				text += info.Tags[i].GetLabel();
				if (i < info.Tags.Count - 1)
				{
					text += ", ";
				}
			}
			_tags.text = "Length: " + info.Duration.GetLabel() + "\n\nDifficulty: " + info.Difficulty.GetLabel() + "\n\nTags: " + text;
			_times.text = "Uploaded: " + info.Uploaded + "\n\nUpdated: " + info.Updated + "\n\n";
			SharerManager.DoGetSprite(info.IconURL, _img);
			_userTitle.text = info.CreatorName;
			_status.text = "Downloading a level will overwrite existing level files\n" + $"Downloading a save will overwrite slot {Settings.SaveSlot.Value}";
			((MonoBehaviour)this).StartCoroutine(RequestManager.GetUserInfo(new UserInfo(info.CreatorId, usingToken: false), delegate(string _, string desc, string pfp)
			{
				_userDesc.text = desc;
				SharerManager.DoGetSprite(pfp, _userImg);
			}));
		}

		private void SetupFilterZone()
		{
			//IL_0016: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_051c: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_0694: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0711: Unknown result type (might be due to invalid IL or missing references)
			//IL_0740: Unknown result type (might be due to invalid IL or missing references)
			//IL_076f: Unknown result type (might be due to invalid IL or missing references)
			//IL_079e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07df: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_083c: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Unknown result type (might be due to invalid IL or missing references)
			//IL_089a: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0927: Unknown result type (might be due to invalid IL or missing references)
			//IL_0956: Unknown result type (might be due to invalid IL or missing references)
			//IL_0988: Unknown result type (might be due to invalid IL or missing references)
			//IL_0997: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a23: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0adf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b54: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b63: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b73: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb3: Expected O, but got Unknown
			//IL_0bce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bdd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bfc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c32: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c3c: Expected O, but got Unknown
			_filter.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 15f);
			UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Name Title", _filter, new Vector2(-105f, 245f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent).fontSize = 18;
			((Text)textComponent).text = "Search Query";
			((Text)textComponent).alignment = (TextAnchor)3;
			UIUtils.Label label;
			(_searchField, label) = UIUtils.MakeTextbox("Name Input", _filter, new Vector2(0f, 215f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 800f, 65f);
			((Text)label.textComponent).fontSize = 15;
			((Component)label).transform.localScale = Vector3.one;
			RectTransform val = (RectTransform)((Component)label).transform;
			val.sizeDelta /= 3f;
			_searchField.characterLimit = 30;
			UIUtils.TruncatableText textComponent2 = UIUtils.MakeLabel("Username Title", _filter, new Vector2(-105f, 165f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent2).fontSize = 18;
			((Text)textComponent2).text = "Creator";
			((Text)textComponent2).alignment = (TextAnchor)3;
			UIUtils.Label label2;
			(_usernameField, label2) = UIUtils.MakeTextbox("Username Input", _filter, new Vector2(0f, 135f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 800f, 65f);
			((Text)label2.textComponent).fontSize = 15;
			((Component)label2).transform.localScale = Vector3.one;
			RectTransform val2 = (RectTransform)((Component)label2).transform;
			val2.sizeDelta /= 3f;
			_usernameField.characterLimit = 30;
			UIUtils.TruncatableText textComponent3 = UIUtils.MakeLabel("I Length Title", _filter, new Vector2(-180f, 85f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent3).fontSize = 18;
			((Text)textComponent3).text = "Include Length";
			((Text)textComponent3).alignment = (TextAnchor)4;
			MakeTagBtn(LevelInfo.LevelDuration.None.GetLabel(), LevelInfo.LevelDuration.None, new Vector2(-225f, 55f), ref _durationButtons, FlipDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Tiny.GetLabel(), LevelInfo.LevelDuration.Tiny, new Vector2(-135f, 55f), ref _durationButtons, FlipDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Short.GetLabel(), LevelInfo.LevelDuration.Short, new Vector2(-270f, 25f), ref _durationButtons, FlipDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Medium.GetLabel(), LevelInfo.LevelDuration.Medium, new Vector2(-180f, 25f), ref _durationButtons, FlipDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Long.GetLabel(), LevelInfo.LevelDuration.Long, new Vector2(-90f, 25f), ref _durationButtons, FlipDuration);
			UIUtils.TruncatableText textComponent4 = UIUtils.MakeLabel("E Length Title", _filter, new Vector2(180f, 85f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent4).fontSize = 18;
			((Text)textComponent4).text = "Exclude Length";
			((Text)textComponent4).alignment = (TextAnchor)4;
			MakeTagBtn(LevelInfo.LevelDuration.None.GetLabel(), LevelInfo.LevelDuration.None, new Vector2(135f, 55f), ref _durationButtons, FlipEDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Tiny.GetLabel(), LevelInfo.LevelDuration.Tiny, new Vector2(225f, 55f), ref _durationButtons, FlipEDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Short.GetLabel(), LevelInfo.LevelDuration.Short, new Vector2(90f, 25f), ref _durationButtons, FlipEDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Medium.GetLabel(), LevelInfo.LevelDuration.Medium, new Vector2(180f, 25f), ref _durationButtons, FlipEDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Long.GetLabel(), LevelInfo.LevelDuration.Long, new Vector2(270f, 25f), ref _durationButtons, FlipEDuration);
			UIUtils.TruncatableText textComponent5 = UIUtils.MakeLabel("Difficulty Title", _filter, new Vector2(-180f, -25f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent5).fontSize = 18;
			((Text)textComponent5).text = "Include Difficulty";
			((Text)textComponent5).alignment = (TextAnchor)4;
			MakeTagBtn(LevelInfo.LevelDifficulty.None.GetLabel(), LevelInfo.LevelDifficulty.None, new Vector2(-225f, -55f), ref _difficultyButtons, FlipDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Easy.GetLabel(), LevelInfo.LevelDifficulty.Easy, new Vector2(-135f, -55f), ref _difficultyButtons, FlipDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Medium.GetLabel(), LevelInfo.LevelDifficulty.Medium, new Vector2(-270f, -85f), ref _difficultyButtons, FlipDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Hard.GetLabel(), LevelInfo.LevelDifficulty.Hard, new Vector2(-180f, -85f), ref _difficultyButtons, FlipDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.ExtraHard.GetLabel(), LevelInfo.LevelDifficulty.ExtraHard, new Vector2(-90f, -85f), ref _difficultyButtons, FlipDifficulty);
			UIUtils.TruncatableText textComponent6 = UIUtils.MakeLabel("Difficulty Title", _filter, new Vector2(180f, -25f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent6).fontSize = 18;
			((Text)textComponent6).text = "Exclude Difficulty";
			((Text)textComponent6).alignment = (TextAnchor)4;
			MakeTagBtn(LevelInfo.LevelDifficulty.None.GetLabel(), LevelInfo.LevelDifficulty.None, new Vector2(135f, -55f), ref _difficultyButtons, FlipEDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Easy.GetLabel(), LevelInfo.LevelDifficulty.Easy, new Vector2(225f, -55f), ref _difficultyButtons, FlipEDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Medium.GetLabel(), LevelInfo.LevelDifficulty.Medium, new Vector2(90f, -85f), ref _difficultyButtons, FlipEDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Hard.GetLabel(), LevelInfo.LevelDifficulty.Hard, new Vector2(180f, -85f), ref _difficultyButtons, FlipEDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.ExtraHard.GetLabel(), LevelInfo.LevelDifficulty.ExtraHard, new Vector2(270f, -85f), ref _difficultyButtons, FlipEDifficulty);
			UIUtils.TruncatableText textComponent7 = UIUtils.MakeLabel("Tag Title", _filter, new Vector2(-180f, -125f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent7).fontSize = 18;
			((Text)textComponent7).text = "Include Tags";
			((Text)textComponent7).alignment = (TextAnchor)4;
			MakeTagBtn(LevelInfo.LevelTag.Platforming.GetLabel(), LevelInfo.LevelTag.Platforming, new Vector2(-225f, -155f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Gauntlets.GetLabel(), LevelInfo.LevelTag.Gauntlets, new Vector2(-135f, -155f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Bosses.GetLabel(), LevelInfo.LevelTag.Bosses, new Vector2(-270f, -185f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Areas.GetLabel(), LevelInfo.LevelTag.Areas, new Vector2(-180f, -185f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Minigames.GetLabel(), LevelInfo.LevelTag.Minigames, new Vector2(-90f, -185f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Multiplayer.GetLabel(), LevelInfo.LevelTag.Multiplayer, new Vector2(-225f, -215f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Troll.GetLabel(), LevelInfo.LevelTag.Troll, new Vector2(-135f, -215f), ref _tagButtons, FlipTag);
			UIUtils.TruncatableText textComponent8 = UIUtils.MakeLabel("Tag Title", _filter, new Vector2(180f, -125f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent8).fontSize = 18;
			((Text)textComponent8).text = "Exclude Tags";
			((Text)textComponent8).alignment = (TextAnchor)4;
			MakeTagBtn(LevelInfo.LevelTag.Platforming.GetLabel(), LevelInfo.LevelTag.Platforming, new Vector2(135f, -155f), ref _tagButtons, FlipETag);
			MakeTagBtn(LevelInfo.LevelTag.Gauntlets.GetLabel(), LevelInfo.LevelTag.Gauntlets, new Vector2(225f, -155f), ref _tagButtons, FlipETag);
			MakeTagBtn(LevelInfo.LevelTag.Bosses.GetLabel(), LevelInfo.LevelTag.Bosses, new Vector2(90f, -185f), ref _tagButtons, FlipETag);
			MakeTagBtn(LevelInfo.LevelTag.Areas.GetLabel(), LevelInfo.LevelTag.Areas, new Vector2(180f, -185f), ref _tagButtons, FlipETag);
			MakeTagBtn(LevelInfo.LevelTag.Minigames.GetLabel(), LevelInfo.LevelTag.Minigames, new Vector2(270f, -185f), ref _tagButtons, FlipETag);
			MakeTagBtn(LevelInfo.LevelTag.Multiplayer.GetLabel(), LevelInfo.LevelTag.Multiplayer, new Vector2(135f, -215f), ref _tagButtons, FlipETag);
			MakeTagBtn(LevelInfo.LevelTag.Troll.GetLabel(), LevelInfo.LevelTag.Troll, new Vector2(225f, -215f), ref _tagButtons, FlipETag);
			var (val3, label3) = UIUtils.MakeTextButton("Clear", "Clear Filter", _filter, new Vector2(-80f, -265f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label3.textComponent).fontSize = 18;
			((UnityEvent)val3.onClick).AddListener(new UnityAction(WipeFilters));
			var (val4, label4) = UIUtils.MakeTextButton("Search", "Search", _filter, new Vector2(80f, -265f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label4.textComponent).fontSize = 18;
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				_browse.SetActive(true);
				_filter.SetActive(false);
				_filterInfo.Active = true;
				_filterInfo.SearchQuery = _searchField.text;
				_filterInfo.UsernameFilter = _usernameField.text;
				RefreshButtons();
				DoSearch();
			});
			_filter.SetActive(false);
		}

		private void SetupLevelZone()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: 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_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: 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_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Expected O, but got Unknown
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Expected O, but got Unknown
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Expected O, but got Unknown
			Sprite sprite = ResourceUtils.LoadSpriteResource("Sharer.downloads", (FilterMode)1);
			(ScrollRect, GameObject, GameObject) tuple = UIUtils.MakeScrollView("Scroll", _browse, new Vector2(-22.5f, -30f), new Vector2(362.5f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(635f, 400f), 1500);
			_scrollRect = tuple.Item1;
			GameObject item = tuple.Item2;
			for (int i = 0; i < 15; i++)
			{
				GameObject val = new GameObject($"Listing {i}");
				val.transform.SetParent(item.transform, false);
				val.RemoveOffset();
				Image val2 = UIUtils.MakeImage("Icon", val, new Vector2(-259f, 5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 200f));
				val2.preserveAspect = true;
				UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Title", val, new Vector2(19f, 40f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 440f, 20f, (HorizontalWrapMode)1).textComponent;
				((Text)textComponent).fontSize = 17;
				((Text)textComponent).horizontalOverflow = (HorizontalWrapMode)0;
				((Text)textComponent).alignment = (TextAnchor)0;
				UIUtils.TruncatableText textComponent2 = UIUtils.MakeLabel("Desc", val, new Vector2(15f, -15f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 420f, 80f, (HorizontalWrapMode)1).textComponent;
				((Text)textComponent2).fontSize = 15;
				((Text)textComponent2).horizontalOverflow = (HorizontalWrapMode)0;
				((Text)textComponent2).alignment = (TextAnchor)0;
				UIUtils.TruncatableText textComponent3 = UIUtils.MakeLabel("Download Count", val, new Vector2(270f, 12.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
				((Text)textComponent3).alignment = (TextAnchor)4;
				UIUtils.TruncatableText likes = UIUtils.MakeLabel("Like Count", val, new Vector2(270f, -18.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
				((Text)likes).alignment = (TextAnchor)4;
				Image val3 = UIUtils.MakeImage("Download Icon", val, new Vector2(299f, 15f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(40f, 40f));
				val3.sprite = sprite;
				(Button, Image, UIUtils.Label) tuple2 = UIUtils.MakeButtonWithImage("Like Icon", val, new Vector2(299f, -15f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 60, 60, doOutline: false);
				Button item2 = tuple2.Item1;
				Image likeImg = tuple2.Item2;
				Image val4 = UIUtils.MakeImage("Selected Icon", val, new Vector2(-315f, 5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(5f, 140f));
				val4.sprite = UIUtils.Square;
				((Component)val4).gameObject.SetActive(false);
				ListingInstance listingInstance = val.AddComponent<ListingInstance>();
				listingInstance.selected = ((Component)val4).gameObject;
				Listing listObject = new Listing(listingInstance, (Text)(object)textComponent, (Text)(object)textComponent2, val2, (Text)(object)likes, (Text)(object)textComponent3, ((Component)val3).gameObject, likeImg, ((Component)item2).gameObject);
				_listings.Add(listObject);
				listObject.Setup(null);
				((UnityEvent)item2.onClick).AddListener(new UnityAction(OnLike));
				void OnLike()
				{
					if (listObject.Info != null && !listObject.Info.Liked && RequestManager.SharerKey != null)
					{
						listObject.Info.Liked = true;
						likeImg.sprite = Like;
						((Text)likes).text = (listObject.Info.LikeCount + 1).ToString();
						((MonoBehaviour)this).StartCoroutine(RequestManager.LikeLevel(listObject.Info.LevelId));
					}
				}
			}
			_pageCounter = (Text)(object)UIUtils.MakeLabel("Page Number", _browse, new Vector2(-22.5f, -270f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_pageCounter.fontSize = 17;
			_pageCounter.alignment = (TextAnchor)4;
			var (val5, label) = UIUtils.MakeTextButton("Arrow Left", "<=", _browse, new Vector2(-72.5f, -270f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(100f, 100f));
			((Text)label.textComponent).fontSize = 15;
			((Text)label.textComponent).alignment = (TextAnchor)4;
			((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
			{
				page--;
				if (page < 0)
				{
					page = totalPages;
				}
				DoSearch();
			});
			var (val6, label2) = UIUtils.MakeTextButton("Arrow Right", "=>", _browse, new Vector2(27.5f, -270f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(100f, 100f));
			((Text)label2.textComponent).fontSize = 15;
			((Text)label2.textComponent).alignment = (TextAnchor)4;
			((UnityEvent)val6.onClick).AddListener((UnityAction)delegate
			{
				page++;
				if (page > totalPages)
				{
					page = 0;
				}
				DoSearch();
			});
		}

		private int FlipDuration(LevelInfo.LevelDuration obj)
		{
			if (_filterInfo.IncludedDurations.Remove(obj))
			{
				return -1;
			}
			_filterInfo.IncludedDurations.Add(obj);
			return 0;
		}

		private int FlipDifficulty(LevelInfo.LevelDifficulty obj)
		{
			if (_filterInfo.IncludedDifficulty.Remove(obj))
			{
				return -1;
			}
			_filterInfo.IncludedDifficulty.Add(obj);
			return 0;
		}

		private int FlipTag(LevelInfo.LevelTag obj)
		{
			if (_filterInfo.IncludedTags.Remove(obj))
			{
				return -1;
			}
			_filterInfo.IncludedTags.Add(obj);
			return 0;
		}

		private int FlipEDuration(LevelInfo.LevelDuration obj)
		{
			if (_filterInfo.ExcludedDurations.Remove(obj))
			{
				return -1;
			}
			_filterInfo.ExcludedDurations.Add(obj);
			return 1;
		}

		private int FlipEDifficulty(LevelInfo.LevelDifficulty obj)
		{
			if (_filterInfo.ExcludedDifficulty.Remove(obj))
			{
				return -1;
			}
			_filterInfo.ExcludedDifficulty.Add(obj);
			return 1;
		}

		private int FlipETag(LevelInfo.LevelTag obj)
		{
			if (_filterInfo.ExcludedTags.Remove(obj))
			{
				return -1;
			}
			_filterInfo.ExcludedTags.Add(obj);
			return 1;
		}

		private void DoSearch()
		{
			((MonoBehaviour)this).StartCoroutine(Search());
		}

		[IteratorStateMachine(typeof(<Search>d__59))]
		private IEnumerator Search()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Search>d__59(0)
			{
				<>4__this = this
			};
		}

		private void MakeTagBtn<T>(string btnName, T value, Vector2 pos, ref Dictionary<T, Button> buttons, Func<T, int> onClick)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			var (btn, label) = UIUtils.MakeTextButton(btnName, btnName, _filter, pos, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(220f, 60f));
			((Text)label.textComponent).fontSize = 15;
			((UnityEvent)btn.onClick).AddListener((UnityAction)delegate
			{
				//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_0046: 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_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				Button val = btn;
				int num = onClick(value);
				if (1 == 0)
				{
				}
				ColorBlock colors = (ColorBlock)(num switch
				{
					0 => ActiveGreen, 
					1 => ActiveRed, 
					_ => Inactive, 
				});
				if (1 == 0)
				{
				}
				((Selectable)val).colors = colors;
			});
			_filterBtns.Add(btn);
			buttons[value] = btn;
		}

		static Browse()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = Color.yellow;
			((ColorBlock)(ref val)).highlightedColor = Color.yellow;
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).selectedColor = Color.yellow;
			((ColorBlock)(ref val)).pressedColor = UIUtils.LightGrey;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			Active = val;
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = Color.green;
			((ColorBlock)(ref val)).highlightedColor = Color.green;
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).selectedColor = Color.green;
			((ColorBlock)(ref val)).pressedColor = UIUtils.LightGrey;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ActiveGreen = val;
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = Color.red;
			((ColorBlock)(ref val)).highlightedColor = Color.red;
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).selectedColor = Color.red;
			((ColorBlock)(ref val)).pressedColor = UIUtils.LightGrey;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ActiveRed = val;
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = Color.white;
			((ColorBlock)(ref val)).highlightedColor = Color.white;
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).selectedColor = Color.white;
			((ColorBlock)(ref val)).pressedColor = UIUtils.LightGrey;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			Inactive = val;
			BlankLike = ResourceUtils.LoadSpriteResource("Sharer.blank_up", (FilterMode)1);
			Like = ResourceUtils.LoadSpriteResource("Sharer.up", (FilterMode)1);
		}
	}
	public class Home : MenuState
	{
		public static MenuState Manage;

		public static MenuState LevelConfig;

		private static Button _manageBtn;

		private static Button _uploadBtn;

		private Text _txt;

		public override void OnStart()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			Image val = UIUtils.MakeImage("Title", ((Component)this).gameObject, new Vector2(0f, 95f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(1030f, 1030f));
			val.preserveAspect = true;
			val.sprite = ResourceUtils.LoadSpriteResource("Sharer.title", (FilterMode)1);
			(Button, UIUtils.Label) tuple = UIUtils.MakeTextButton("Account", "Account", ((Component)this).gameObject, new Vector2(0f, -40f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			Button item = tuple.Item1;
			UIUtils.Label item2 = tuple.Item2;
			_txt = (Text)(object)item2.textComponent;
			_txt.fontSize = 20;
			MenuState login = SharerManager.SetupMenuState<Login>("Login");
			MenuState account = SharerManager.SetupMenuState<Account>("Account");
			((UnityEvent)item.onClick).AddListener((UnityAction)delegate
			{
				SharerManager.TransitionToState((RequestManager.SharerKey == null) ? login : account);
			});
			MakeButton<Browse>("Browse Levels", -80f);
			(LevelConfig, _uploadBtn) = MakeButton<LevelConfig>("Upload", -120f);
			(Manage, _manageBtn) = MakeButton<Manage>("Manage Levels", -160f);
		}

		public override void OnOpen()
		{
			Architect.Sharer.States.LevelConfig.CurrentInfo = null;
		}

		private (MenuState, Button) MakeButton<T>(string stateName, float y) where T : MenuState
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			var (val, label) = UIUtils.MakeTextButton(stateName, stateName, ((Component)this).gameObject, new Vector2(0f, y), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 85f));
			((Text)label.textComponent).fontSize = 20;
			MenuState state = SharerManager.SetupMenuState<T>(stateName);
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				SharerManager.TransitionToState(state);
			});
			return (state, val);
		}

		private void Update()
		{
			_txt.text = ((RequestManager.SharerKey == null) ? "Log In / Sign Up" : "Account");
			((Selectable)_manageBtn).interactable = RequestManager.SharerKey != null;
			((Selectable)_uploadBtn).interactable = RequestManager.SharerKey != null;
		}
	}
	public class LevelConfig : MenuState
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass17_0
		{
			private sealed class <<OnStart>g__Return|6>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public MenuState state;

				public <>c__DisplayClass17_0 <>4__this;

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

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

				[DebuggerHidden]
				public <<OnStart>g__Return|6>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						((Selectable)<>4__this.uploadBtn).interactable = true;
						((Selectable)<>4__this.applyBtn).interactable = true;
						((Selectable)<>4__this.overwriteSaveBtn).interactable = true;
						((Selectable)<>4__this.overwriteBtn).interactable = true;
						((Text)<>4__this.status).text = "";
						SharerManager.TransitionToState(state);
						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 Image iconImg;

			public Button uploadBtn;

			public Button applyBtn;

			public Button overwriteSaveBtn;

			public Button overwriteBtn;

			public LevelConfig <>4__this;

			public UIUtils.TruncatableText status;

			internal void <OnStart>b__0(string s)
			{
				SharerManager.DoGetSprite(s, iconImg);
			}

			internal void <OnStart>b__1()
			{
				Upload();
				[IteratorStateMachine(typeof(<<OnStart>g__Return|6>d))]
				IEnumerator Return(MenuState state)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<OnStart>g__Return|6>d(0)
					{
						<>4__this = this,
						state = state
					};
				}
				void Upload([CanBeNull] string overwriteLevelId = null, int overwriteMode = -1)
				{
					((Selectable)uploadBtn).interactable = false;
					((Selectable)applyBtn).interactable = false;
					((Selectable)overwriteSaveBtn).interactable = false;
					((Selectable)overwriteBtn).interactable = false;
					if (!int.TryParse(<>4__this._saveField.text, out var result))
					{
						result = -1;
					}
					((MonoBehaviour)<>4__this).StartCoroutine(RequestManager.UploadLevel(<>4__this._nameField.text, <>4__this._descField.text, <>4__this._iconField.text, result, <>4__this._difficulty, <>4__this._duration, <>4__this._tags, delegate(bool success, string message)
					{
						((Text)status).text = message;
						if (success)
						{
							((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Return(<>4__this.ReturnState));
						}
						else
						{
							((Selectable)uploadBtn).interactable = true;
							((Selectable)applyBtn).interactable = true;
							((Selectable)overwriteSaveBtn).interactable = true;
							((Selectable)overwriteBtn).interactable = true;
						}
					}, overwriteLevelId, overwriteMode));
				}
			}

			internal void <OnStart>b__2()
			{
				Upload(CurrentInfo.LevelId, 0);
				[IteratorStateMachine(typeof(<<OnStart>g__Return|6>d))]
				IEnumerator Return(MenuState state)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<OnStart>g__Return|6>d(0)
					{
						<>4__this = this,
						state = state
					};
				}
				void Upload([CanBeNull] string overwriteLevelId = null, int overwriteMode = -1)
				{
					((Selectable)uploadBtn).interactable = false;
					((Selectable)applyBtn).interactable = false;
					((Selectable)overwriteSaveBtn).interactable = false;
					((Selectable)overwriteBtn).interactable = false;
					if (!int.TryParse(<>4__this._saveField.text, out var result))
					{
						result = -1;
					}
					((MonoBehaviour)<>4__this).StartCoroutine(RequestManager.UploadLevel(<>4__this._nameField.text, <>4__this._descField.text, <>4__this._iconField.text, result, <>4__this._difficulty, <>4__this._duration, <>4__this._tags, delegate(bool success, string message)
					{
						((Text)status).text = message;
						if (success)
						{
							((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Return(<>4__this.ReturnState));
						}
						else
						{
							((Selectable)uploadBtn).interactable = true;
							((Selectable)applyBtn).interactable = true;
							((Selectable)overwriteSaveBtn).interactable = true;
							((Selectable)overwriteBtn).interactable = true;
						}
					}, overwriteLevelId, overwriteMode));
				}
			}

			internal void <OnStart>b__3()
			{
				Upload(CurrentInfo.LevelId, 1);
				[IteratorStateMachine(typeof(<<OnStart>g__Return|6>d))]
				IEnumerator Return(MenuState state)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<OnStart>g__Return|6>d(0)
					{
						<>4__this = this,
						state = state
					};
				}
				void Upload([CanBeNull] string overwriteLevelId = null, int overwriteMode = -1)
				{
					((Selectable)uploadBtn).interactable = false;
					((Selectable)applyBtn).interactable = false;
					((Selectable)overwriteSaveBtn).interactable = false;
					((Selectable)overwriteBtn).interactable = false;
					if (!int.TryParse(<>4__this._saveField.text, out var result))
					{
						result = -1;
					}
					((MonoBehaviour)<>4__this).StartCoroutine(RequestManager.UploadLevel(<>4__this._nameField.text, <>4__this._descField.text, <>4__this._iconField.text, result, <>4__this._difficulty, <>4__this._duration, <>4__this._tags, delegate(bool success, string message)
					{
						((Text)status).text = message;
						if (success)
						{
							((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Return(<>4__this.ReturnState));
						}
						else
						{
							((Selectable)uploadBtn).interactable = true;
							((Selectable)applyBtn).interactable = true;
							((Selectable)overwriteSaveBtn).interactable = true;
							((Selectable)overwriteBtn).interactable = true;
						}
					}, overwriteLevelId, overwriteMode));
				}
			}

			internal void <OnStart>b__4()
			{
				Upload(CurrentInfo.LevelId, 2);
				[IteratorStateMachine(typeof(<<OnStart>g__Return|6>d))]
				IEnumerator Return(MenuState state)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<OnStart>g__Return|6>d(0)
					{
						<>4__this = this,
						state = state
					};
				}
				void Upload([CanBeNull] string overwriteLevelId = null, int overwriteMode = -1)
				{
					((Selectable)uploadBtn).interactable = false;
					((Selectable)applyBtn).interactable = false;
					((Selectable)overwriteSaveBtn).interactable = false;
					((Selectable)overwriteBtn).interactable = false;
					if (!int.TryParse(<>4__this._saveField.text, out var result))
					{
						result = -1;
					}
					((MonoBehaviour)<>4__this).StartCoroutine(RequestManager.UploadLevel(<>4__this._nameField.text, <>4__this._descField.text, <>4__this._iconField.text, result, <>4__this._difficulty, <>4__this._duration, <>4__this._tags, delegate(bool success, string message)
					{
						((Text)status).text = message;
						if (success)
						{
							((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Return(<>4__this.ReturnState));
						}
						else
						{
							((Selectable)uploadBtn).interactable = true;
							((Selectable)applyBtn).interactable = true;
							((Selectable)overwriteSaveBtn).interactable = true;
							((Selectable)overwriteBtn).interactable = true;
						}
					}, overwriteLevelId, overwriteMode));
				}
			}

			internal void <OnStart>b__7(bool success, string message)
			{
				((Text)status).text = message;
				if (success)
				{
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Return(<>4__this.ReturnState));
					return;
				}
				((Selectable)uploadBtn).interactable = true;
				((Selectable)applyBtn).interactable = true;
				((Selectable)overwriteSaveBtn).interactable = true;
				((Selectable)overwriteBtn).interactable = true;
				[IteratorStateMachine(typeof(<<OnStart>g__Return|6>d))]
				IEnumerator Return(MenuState state)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<OnStart>g__Return|6>d(0)
					{
						<>4__this = this,
						state = state
					};
				}
			}
		}

		private InputField _nameField;

		private InputField _saveField;

		private InputField _descField;

		private InputField _iconField;

		private (GameObject, GameObject) _upload;

		private (GameObject, GameObject) _overwriteLevel;

		private (GameObject, GameObject) _overwriteSave;

		private (GameObject, GameObject) _apply;

		private Dictionary<LevelInfo.LevelDuration, Button> _durationButtons = new Dictionary<LevelInfo.LevelDuration, Button>();

		private Dictionary<LevelInfo.LevelDifficulty, Button> _difficultyButtons = new Dictionary<LevelInfo.LevelDifficulty, Button>();

		private Dictionary<LevelInfo.LevelTag, Button> _tagButtons = new Dictionary<LevelInfo.LevelTag, Button>();

		private LevelInfo.LevelDuration _duration;

		private LevelInfo.LevelDifficulty _difficulty;

		private List<LevelInfo.LevelTag> _tags;

		public static LevelInfo CurrentInfo;

		public override MenuState ReturnState => (CurrentInfo == null) ? SharerManager.HomeState : Home.Manage;

		public override void OnStart()
		{
			//IL_001e: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_0595: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0621: Unknown result type (might be due to invalid IL or missing references)
			//IL_0650: Unknown result type (might be due to invalid IL or missing references)
			//IL_067f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_074c: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_07aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0808: Unknown result type (might be due to invalid IL or missing references)
			//IL_083a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_0858: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0904: Unknown result type (might be due to invalid IL or missing references)
			//IL_0933: Unknown result type (might be due to invalid IL or missing references)
			//IL_0962: Unknown result type (might be due to invalid IL or missing references)
			//IL_0991: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a02: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a11: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a83: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a93: Unknown result type (might be due to invalid IL or missing references)
			//IL_0afb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b19: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b91: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0baf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bbf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c55: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cbf: Expected O, but got Unknown
			//IL_0cd2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cdc: Expected O, but got Unknown
			//IL_0cef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf9: Expected O, but got Unknown
			//IL_0d0c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d16: Expected O, but got Unknown
			<>c__DisplayClass17_0 CS$<>8__locals0 = new <>c__DisplayClass17_0();
			CS$<>8__locals0.<>4__this = this;
			((Component)this).GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 10f);
			UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Name Title", ((Component)this).gameObject, new Vector2(-200f, 245f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent).fontSize = 18;
			((Text)textComponent).text = "Level Name";
			((Text)textComponent).alignment = (TextAnchor)3;
			UIUtils.Label label;
			(_nameField, label) = UIUtils.MakeTextbox("Name Input", ((Component)this).gameObject, new Vector2(-95f, 215f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 800f, 65f);
			((Text)label.textComponent).fontSize = 15;
			((Component)label).transform.localScale = Vector3.one;
			RectTransform val = (RectTransform)((Component)label).transform;
			val.sizeDelta /= 3f;
			_nameField.characterLimit = 40;
			UIUtils.TruncatableText textComponent2 = UIUtils.MakeLabel("Desc Title", ((Component)this).gameObject, new Vector2(-200f, 185f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent2).fontSize = 18;
			((Text)textComponent2).text = "Level Description";
			((Text)textComponent2).alignment = (TextAnchor)3;
			UIUtils.Label label2;
			(_descField, label2) = UIUtils.MakeTextbox("Desc Input", ((Component)this).gameObject, new Vector2(-45f, 132.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 1100f, 205f);
			((Text)label2.textComponent).fontSize = 15;
			((Text)label2.textComponent).alignment = (TextAnchor)0;
			((Component)label2).transform.localScale = Vector3.one;
			_descField.lineType = (LineType)2;
			_descField.characterLimit = 300;
			RectTransform val2 = (RectTransform)((Component)label2).transform;
			val2.sizeDelta = new Vector2(val2.sizeDelta.x / 3f, 70f);
			val2.anchoredPosition = new Vector2(-45f, 130f);
			UIUtils.TruncatableText textComponent3 = UIUtils.MakeLabel("Save Title", ((Component)this).gameObject, new Vector2(-200f, 75f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent3).fontSize = 18;
			((Text)textComponent3).text = "Attached Save (Optional)";
			((Text)textComponent3).alignment = (TextAnchor)3;
			UIUtils.Label label3;
			(_saveField, label3) = UIUtils.MakeTextbox("Save Input", ((Component)this).gameObject, new Vector2(-212f, 45f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 100f, 65f);
			((Text)label3.textComponent).fontSize = 15;
			((Component)label3).transform.localScale = Vector3.one;
			RectTransform val3 = (RectTransform)((Component)label3).transform;
			val3.sizeDelta /= 3f;
			_saveField.contentType = (ContentType)2;
			_saveField.characterLimit = 2;
			UIUtils.TruncatableText textComponent4 = UIUtils.MakeLabel("Icon Title", ((Component)this).gameObject, new Vector2(225f, 75f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent4).fontSize = 18;
			((Text)textComponent4).text = "Icon URL";
			((Text)textComponent4).alignment = (TextAnchor)4;
			CS$<>8__locals0.iconImg = UIUtils.MakeImage("Icon", ((Component)this).gameObject, new Vector2(225f, 145f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 200f));
			CS$<>8__locals0.iconImg.preserveAspect = true;
			CS$<>8__locals0.iconImg.sprite = SharerManager.Placeholder;
			UIUtils.Label label4;
			(_iconField, label4) = UIUtils.MakeTextbox("Icon URL", ((Component)this).gameObject, new Vector2(225f, 45f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 300f, 65f);
			((UnityEvent<string>)(object)_iconField.onEndEdit).AddListener((UnityAction<string>)delegate(string s)
			{
				SharerManager.DoGetSprite(s, CS$<>8__locals0.iconImg);
			});
			((Text)label4.textComponent).fontSize = 15;
			((Component)label4).transform.localScale = Vector3.one;
			RectTransform val4 = (RectTransform)((Component)label4).transform;
			val4.sizeDelta /= 3f;
			UIUtils.TruncatableText textComponent5 = UIUtils.MakeLabel("Length Title", ((Component)this).gameObject, new Vector2(-200f, -10f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent5).fontSize = 18;
			((Text)textComponent5).text = "Length";
			((Text)textComponent5).alignment = (TextAnchor)3;
			MakeTagBtn(LevelInfo.LevelDuration.None.GetLabel(), LevelInfo.LevelDuration.None, new Vector2(-180f, -40f), ref _durationButtons, SetDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Tiny.GetLabel(), LevelInfo.LevelDuration.Tiny, new Vector2(-90f, -40f), ref _durationButtons, SetDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Short.GetLabel(), LevelInfo.LevelDuration.Short, new Vector2(0f, -40f), ref _durationButtons, SetDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Medium.GetLabel(), LevelInfo.LevelDuration.Medium, new Vector2(90f, -40f), ref _durationButtons, SetDuration);
			MakeTagBtn(LevelInfo.LevelDuration.Long.GetLabel(), LevelInfo.LevelDuration.Long, new Vector2(180f, -40f), ref _durationButtons, SetDuration);
			UIUtils.TruncatableText textComponent6 = UIUtils.MakeLabel("Difficulty Title", ((Component)this).gameObject, new Vector2(-200f, -80f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent6).fontSize = 18;
			((Text)textComponent6).text = "Difficulty";
			((Text)textComponent6).alignment = (TextAnchor)3;
			MakeTagBtn(LevelInfo.LevelDifficulty.None.GetLabel(), LevelInfo.LevelDifficulty.None, new Vector2(-180f, -110f), ref _difficultyButtons, SetDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Easy.GetLabel(), LevelInfo.LevelDifficulty.Easy, new Vector2(-90f, -110f), ref _difficultyButtons, SetDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Medium.GetLabel(), LevelInfo.LevelDifficulty.Medium, new Vector2(0f, -110f), ref _difficultyButtons, SetDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.Hard.GetLabel(), LevelInfo.LevelDifficulty.Hard, new Vector2(90f, -110f), ref _difficultyButtons, SetDifficulty);
			MakeTagBtn(LevelInfo.LevelDifficulty.ExtraHard.GetLabel(), LevelInfo.LevelDifficulty.ExtraHard, new Vector2(180f, -110f), ref _difficultyButtons, SetDifficulty);
			UIUtils.TruncatableText textComponent7 = UIUtils.MakeLabel("Tag Title", ((Component)this).gameObject, new Vector2(-200f, -150f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent7).fontSize = 18;
			((Text)textComponent7).text = "Tags";
			((Text)textComponent7).alignment = (TextAnchor)3;
			MakeTagBtn(LevelInfo.LevelTag.Platforming.GetLabel(), LevelInfo.LevelTag.Platforming, new Vector2(-135f, -180f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Gauntlets.GetLabel(), LevelInfo.LevelTag.Gauntlets, new Vector2(-45f, -180f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Bosses.GetLabel(), LevelInfo.LevelTag.Bosses, new Vector2(45f, -180f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Minigames.GetLabel(), LevelInfo.LevelTag.Minigames, new Vector2(135f, -180f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Areas.GetLabel(), LevelInfo.LevelTag.Areas, new Vector2(-90f, -210f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Multiplayer.GetLabel(), LevelInfo.LevelTag.Multiplayer, new Vector2(0f, -210f), ref _tagButtons, FlipTag);
			MakeTagBtn(LevelInfo.LevelTag.Troll.GetLabel(), LevelInfo.LevelTag.Troll, new Vector2(90f, -210f), ref _tagButtons, FlipTag);
			CS$<>8__locals0.status = UIUtils.MakeLabel("Status", ((Component)this).gameObject, new Vector2(0f, -290f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)CS$<>8__locals0.status).fontSize = 15;
			((Text)CS$<>8__locals0.status).alignment = (TextAnchor)4;
			UIUtils.Label label5;
			(CS$<>8__locals0.uploadBtn, label5) = UIUtils.MakeTextButton("Upload", "Upload", ((Component)this).gameObject, new Vector2(0f, -260f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label5.textComponent).fontSize = 18;
			_upload = (((Component)CS$<>8__locals0.uploadBtn).gameObject, ((Component)label5).gameObject);
			UIUtils.Label label6;
			(CS$<>8__locals0.applyBtn, label6) = UIUtils.MakeTextButton("Save Changes", "Save Changes", ((Component)this).gameObject, new Vector2(160f, -260f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label6.textComponent).fontSize = 18;
			_apply = (((Component)CS$<>8__locals0.applyBtn).gameObject, ((Component)label6).gameObject);
			UIUtils.Label label7;
			(CS$<>8__locals0.overwriteBtn, label7) = UIUtils.MakeTextButton("Overwrite Level", "Overwrite Level", ((Component)this).gameObject, new Vector2(-160f, -260f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label7.textComponent).fontSize = 18;
			_overwriteLevel = (((Component)CS$<>8__locals0.overwriteBtn).gameObject, ((Component)label7).gameObject);
			UIUtils.Label label8;
			(CS$<>8__locals0.overwriteSaveBtn, label8) = UIUtils.MakeTextButton("Overwrite Save", "Overwrite Save", ((Component)this).gameObject, new Vector2(0f, -260f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label8.textComponent).fontSize = 18;
			_overwriteSave = (((Component)CS$<>8__locals0.overwriteSaveBtn).gameObject, ((Component)label8).gameObject);
			((UnityEvent)CS$<>8__locals0.uploadBtn.onClick).AddListener((UnityAction)delegate
			{
				Upload();
			});
			((UnityEvent)CS$<>8__locals0.applyBtn.onClick).AddListener((UnityAction)delegate
			{
				Upload(CurrentInfo.LevelId, 0);
			});
			((UnityEvent)CS$<>8__locals0.overwriteBtn.onClick).AddListener((UnityAction)delegate
			{
				Upload(CurrentInfo.LevelId, 1);
			});
			((UnityEvent)CS$<>8__locals0.overwriteSaveBtn.onClick).AddListener((UnityAction)delegate
			{
				Upload(CurrentInfo.LevelId, 2);
			});
			[IteratorStateMachine(typeof(<>c__DisplayClass17_0.<<OnStart>g__Return|6>d))]
			IEnumerator Return(MenuState state)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass17_0.<<OnStart>g__Return|6>d(0)
				{
					<>4__this = CS$<>8__locals0,
					state = state
				};
			}
			void Upload([CanBeNull] string overwriteLevelId = null, int overwriteMode = -1)
			{
				((Selectable)CS$<>8__locals0.uploadBtn).interactable = false;
				((Selectable)CS$<>8__locals0.applyBtn).interactable = false;
				((Selectable)CS$<>8__locals0.overwriteSaveBtn).interactable = false;
				((Selectable)CS$<>8__locals0.overwriteBtn).interactable = false;
				if (!int.TryParse(CS$<>8__locals0.<>4__this._saveField.text, out var result))
				{
					result = -1;
				}
				((MonoBehaviour)CS$<>8__locals0.<>4__this).StartCoroutine(RequestManager.UploadLevel(CS$<>8__locals0.<>4__this._nameField.text, CS$<>8__locals0.<>4__this._descField.text, CS$<>8__locals0.<>4__this._iconField.text, result, CS$<>8__locals0.<>4__this._difficulty, CS$<>8__locals0.<>4__this._duration, CS$<>8__locals0.<>4__this._tags, delegate(bool success, string message)
				{
					((Text)CS$<>8__locals0.status).text = message;
					if (success)
					{
						((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Return(CS$<>8__locals0.<>4__this.ReturnState));
					}
					else
					{
						((Selectable)CS$<>8__locals0.uploadBtn).interactable = true;
						((Selectable)CS$<>8__locals0.applyBtn).interactable = true;
						((Selectable)CS$<>8__locals0.overwriteSaveBtn).interactable = true;
						((Selectable)CS$<>8__locals0.overwriteBtn).interactable = true;
					}
				}, overwriteLevelId, overwriteMode));
			}
		}

		private void FlipTag(LevelInfo.LevelTag t)
		{
			if (!_tags.Remove(t))
			{
				_tags.Add(t);
			}
		}

		private void SetDifficulty(LevelInfo.LevelDifficulty difficulty)
		{
			_difficulty = difficulty;
		}

		private void SetDuration(LevelInfo.LevelDuration duration)
		{
			_duration = duration;
		}

		private void MakeTagBtn<T>(string btnName, T value, Vector2 pos, ref Dictionary<T, Button> buttons, Action<T> onClick)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			var (val, label) = UIUtils.MakeTextButton(btnName, btnName, ((Component)this).gameObject, pos, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(220f, 60f));
			((Text)label.textComponent).fontSize = 15;
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				onClick(value);
				RefreshButtons();
			});
			buttons[value] = val;
		}

		public override void OnOpen()
		{
			_saveField.text = "";
			if (CurrentInfo == null)
			{
				_nameField.text = "";
				_descField.text = "";
				_iconField.text = "";
				_difficulty = LevelInfo.LevelDifficulty.None;
				_duration = LevelInfo.LevelDuration.None;
				_tags = new List<LevelInfo.LevelTag>();
				_upload.Item1.SetActive(true);
				_upload.Item2.SetActive(true);
				_apply.Item1.SetActive(false);
				_apply.Item2.SetActive(false);
				_overwriteLevel.Item1.SetActive(false);
				_overwriteLevel.Item2.SetActive(false);
				_overwriteSave.Item1.SetActive(false);
				_overwriteSave.Item2.SetActive(false);
			}
			else
			{
				_nameField.text = CurrentInfo.LevelName;
				_descField.text = CurrentInfo.LevelDesc;
				_iconField.text = CurrentInfo.IconURL;
				_difficulty = CurrentInfo.Difficulty;
				_duration = CurrentInfo.Duration;
				_tags = CurrentInfo.Tags.ToList();
				_upload.Item1.SetActive(false);
				_upload.Item2.SetActive(false);
				_apply.Item1.SetActive(true);
				_apply.Item2.SetActive(true);
				_overwriteLevel.Item1.SetActive(true);
				_overwriteLevel.Item2.SetActive(true);
				_overwriteSave.Item1.SetActive(true);
				_overwriteSave.Item2.SetActive(true);
			}
			((UnityEvent<string>)(object)_iconField.onEndEdit).Invoke(_iconField.text);
			RefreshButtons();
		}

		private void RefreshButtons()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = Color.green;
			((ColorBlock)(ref val)).highlightedColor = Color.green;
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).selectedColor = Color.green;
			((ColorBlock)(ref val)).pressedColor = UIUtils.LightGrey;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ColorBlock val2 = val;
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = Color.white;
			((ColorBlock)(ref val)).highlightedColor = Color.white;
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).selectedColor = Color.white;
			((ColorBlock)(ref val)).pressedColor = UIUtils.LightGrey;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			ColorBlock val3 = val;
			Button value;
			foreach (KeyValuePair<LevelInfo.LevelTag, Button> tagButton in _tagButtons)
			{
				tagButton.Deconstruct(out var key, out value);
				LevelInfo.LevelTag item = key;
				Button val4 = value;
				((Selectable)val4).colors = (_tags.Contains(item) ? val2 : val3);
			}
			foreach (KeyValuePair<LevelInfo.LevelDifficulty, Button> difficultyButton in _difficultyButtons)
			{
				difficultyButton.Deconstruct(out var key2, out value);
				LevelInfo.LevelDifficulty levelDifficulty = key2;
				Button val5 = value;
				((Selectable)val5).colors = ((_difficulty == levelDifficulty) ? val2 : val3);
			}
			foreach (KeyValuePair<LevelInfo.LevelDuration, Button> durationButton in _durationButtons)
			{
				durationButton.Deconstruct(out var key3, out value);
				LevelInfo.LevelDuration levelDuration = key3;
				Button val6 = value;
				((Selectable)val6).colors = ((_duration == levelDuration) ? val2 : val3);
			}
		}
	}
	public class Login : MenuState
	{
		[CompilerGenerated]
		private sealed class <<OnStart>g__Login|7_2>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool signup;

			public Login <>4__this;

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

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

			[DebuggerHidden]
			public <<OnStart>g__Login|7_2>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Selectable)<>4__this._loginBtn).interactable = false;
					((Selectable)<>4__this._signupBtn).interactable = false;
					((Selectable)SharerManager.ReturnBtn).interactable = false;
					<>2__current = RequestManager.Login(signup, <>4__this._userField.text, <>4__this._pwField.text, <>4__this._result);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (RequestManager.SharerKey != null)
					{
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					<>4__this._userField.text = "";
					<>4__this._result.text = "";
					<>4__this._pwField.text = "";
					SharerManager.TransitionToState(SharerManager.HomeState);
					break;
				}
				((Selectable)<>4__this._loginBtn).interactable = true;
				((Selectable)<>4__this._signupBtn).interactable = true;
				((Selectable)SharerManager.ReturnBtn).interactable = true;
				return false;
			}

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

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

		private Button _loginBtn;

		private Button _signupBtn;

		private Text _result;

		private InputField _userField;

		private InputField _pwField;

		public override MenuState ReturnState => SharerManager.HomeState;

		public override void OnStart()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Expected O, but got Unknown
			UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Username Title", ((Component)this).gameObject, new Vector2(-165f, 85f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent).fontSize = 20;
			((Text)textComponent).text = "Username:";
			((Text)textComponent).alignment = (TextAnchor)3;
			UIUtils.Label label;
			(_userField, label) = UIUtils.MakeTextbox("Username Input", ((Component)this).gameObject, new Vector2(0f, 55f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 1225f, 75f);
			((Text)label.textComponent).fontSize = 16;
			((Component)label).transform.localScale = Vector3.one;
			RectTransform val = (RectTransform)((Component)label).transform;
			val.sizeDelta /= 3f;
			_userField.characterLimit = 20;
			UIUtils.TruncatableText textComponent2 = UIUtils.MakeLabel("Password Title", ((Component)this).gameObject, new Vector2(-165f, 5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent2).fontSize = 20;
			((Text)textComponent2).text = "Password:";
			((Text)textComponent2).alignment = (TextAnchor)3;
			UIUtils.Label label2;
			(_pwField, label2) = UIUtils.MakeTextbox("Password Input", ((Component)this).gameObject, new Vector2(0f, -25f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 1225f, 75f);
			((Text)label2.textComponent).fontSize = 16;
			((Component)label2).transform.localScale = Vector3.one;
			RectTransform val2 = (RectTransform)((Component)label2).transform;
			val2.sizeDelta /= 3f;
			_pwField.inputType = (InputType)2;
			UIUtils.Label label3;
			(_loginBtn, label3) = UIUtils.MakeTextButton("Log In", "Log In", ((Component)this).gameObject, new Vector2(-100f, -85f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label3.textComponent).fontSize = 20;
			UIUtils.Label label4;
			(_signupBtn, label4) = UIUtils.MakeTextButton("Sign Up", "Sign Up", ((Component)this).gameObject, new Vector2(100f, -85f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(420f, 80f));
			((Text)label4.textComponent).fontSize = 20;
			_result = (Text)(object)UIUtils.MakeLabel("Status", ((Component)this).gameObject, new Vector2(0f, -140f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_result.fontSize = 16;
			_result.alignment = (TextAnchor)4;
			((UnityEvent)_loginBtn.onClick).AddListener((UnityAction)delegate
			{
				((MonoBehaviour)this).StartCoroutine(Login(signup: false));
			});
			((UnityEvent)_signupBtn.onClick).AddListener((UnityAction)delegate
			{
				((MonoBehaviour)this).StartCoroutine(Login(signup: true));
			});
			[IteratorStateMachine(typeof(<<OnStart>g__Login|7_2>d))]
			IEnumerator Login(bool signup)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<OnStart>g__Login|7_2>d(0)
				{
					<>4__this = this,
					signup = signup
				};
			}
		}

		public override void OnOpen()
		{
			if (((MonoBehaviour)this).didStart)
			{
				((Selectable)_loginBtn).interactable = true;
				((Selectable)_signupBtn).interactable = true;
				_result.text = "";
				_userField.text = "";
				_pwField.text = "";
			}
		}
	}
	public class Manage : MenuState
	{
		public class LevelDisplay
		{
			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private GameObject <parent>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Image <image>P;

			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private Text <text>P;

			public LevelInfo LevelInfo;

			public LevelDisplay(GameObject parent, Image image, Text text)
			{
				<parent>P = parent;
				<image>P = image;
				<text>P = text;
				base..ctor();
			}

			public void Apply(LevelInfo info)
			{
				LevelInfo = info;
				if (info == null)
				{
					<parent>P.SetActive(false);
					return;
				}
				<parent>P.SetActive(true);
				<text>P.text = info.LevelName;
				SharerManager.DoGetSprite(info.IconURL, <image>P);
			}
		}

		public class ShowButtons : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
		{
			public GameObject buttonParent;

			private void OnDisable()
			{
				buttonParent.SetActive(false);
			}

			public void OnPointerEnter(PointerEventData eventData)
			{
				buttonParent.SetActive(true);
			}

			public void OnPointerExit(PointerEventData eventData)
			{
				buttonParent.SetActive(false);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			private sealed class <<SetupDeleteUI>g__OnComplete|3>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public bool b;

				public <>c__DisplayClass14_0 <>4__this;

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

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

				[DebuggerHidden]
				public <<SetupDeleteUI>g__OnComplete|3>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (b)
						{
							<>2__current = <>4__this.<>4__this.RefreshPage();
							<>1__state = 1;
							return true;
						}
						break;
					case 1:
						<>1__state = -1;
						break;
					}
					((Selectable)<>4__this.cancel).interactable = true;
					((Selectable)<>4__this.<>4__this._confirm).interactable = true;
					<>4__this.<>4__this._deleteUI.SetActive(false);
					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 Manage <>4__this;

			public Button cancel;

			public Action<bool> <>9__4;

			internal void <SetupDeleteUI>b__0()
			{
				<>4__this._deleteUI.SetActive(false);
			}

			internal void <SetupDeleteUI>b__1()
			{
				((Selectable)cancel).interactable = false;
				((Selectable)<>4__this._confirm).interactable = false;
				((MonoBehaviour)<>4__this).StartCoroutine(RequestManager.SendDeleteRequest(<>4__this._currentDeleteName, delegate(bool b)
				{
					((MonoBehaviour)<>4__this).StartCoroutine(OnComplete(b));
				}));
				[IteratorStateMachine(typeof(<<SetupDeleteUI>g__OnComplete|3>d))]
				IEnumerator OnComplete(bool b)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<SetupDeleteUI>g__OnComplete|3>d(0)
					{
						<>4__this = this,
						b = b
					};
				}
			}

			internal void <SetupDeleteUI>b__4(bool b)
			{
				((MonoBehaviour)<>4__this).StartCoroutine(OnComplete(b));
				[IteratorStateMachine(typeof(<<SetupDeleteUI>g__OnComplete|3>d))]
				IEnumerator OnComplete(bool b)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<SetupDeleteUI>g__OnComplete|3>d(0)
					{
						<>4__this = this,
						b = b
					};
				}
			}

			internal void <SetupDeleteUI>b__2(string s)
			{
				((Selectable)<>4__this._confirm).interactable = s == <>4__this._currentDeleteName;
			}
		}

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

			private object <>2__current;

			public Manage <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Selectable)<>4__this._leftBtn).interactable = false;
					((Selectable)<>4__this._rightBtn).interactable = false;
					<>2__current = RequestManager.SearchLevels(new RequestManager.FilterInfo
					{
						KeyFilter = RequestManager.SharerKey,
						KeyMode = true
					}, 15, <>4__this.page, delegate(bool success, List<LevelInfo> levels, int pages)
					{
						if (!success)
						{
							SharerManager.TransitionToState(SharerManager.HomeState);
						}
						else
						{
							((Selectable)<>4__this._leftBtn).interactable = <>4__this.page > 0;
							((Selectable)<>4__this._rightBtn).interactable = <>4__this.page < pages;
							int i = 0;
							foreach (LevelInfo level in levels)
							{
								<>4__this._displays[i].Apply(level);
								i++;
							}
							for (; i < <>4__this._displays.Count; i++)
							{
								<>4__this._displays[i].Apply(null);
							}
						}
					});
					<>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();
			}
		}

		public static Manage Instance;

		private readonly List<LevelDisplay> _displays = new List<LevelDisplay>();

		public int page;

		private Button _leftBtn;

		private Button _rightBtn;

		private GameObject _deleteUI;

		private Text _changeTitle;

		private InputField _nameField;

		private Transform _bg;

		private Button _confirm;

		private string _currentDeleteName;

		public override MenuState ReturnState => SharerManager.HomeState;

		public override void OnStart()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Expected O, but got Unknown
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Expected O, but got Unknown
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Expected O, but got Unknown
			Instance = this;
			Sprite sprite = ResourceUtils.LoadSpriteResource("Sharer.bin", (FilterMode)1);
			Sprite sprite2 = ResourceUtils.LoadSpriteResource("Sharer.pen", (FilterMode)1);
			for (int num = 1; num >= -1; num--)
			{
				for (int i = -2; i <= 2; i++)
				{
					GameObject val = new GameObject($"Listing ({i},{num})");
					val.transform.SetParent(((Component)this).transform, false);
					val.RemoveOffset();
					Image val2 = UIUtils.MakeImage("Icon", val, new Vector2((float)(i * 125), (float)(num * 160)), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(200f, 200f));
					val2.preserveAspect = true;
					val2.sprite = ArchitectPlugin.BlankSprite;
					UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Name", val, new Vector2((float)(i * 125), (float)(num * 160 - 65)), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 100f, 80f, (HorizontalWrapMode)1).textComponent;
					((Text)textComponent).alignment = (TextAnchor)4;
					textComponent.truncate = true;
					((Text)textComponent).fontSize = 15;
					GameObject val3 = new GameObject("Controls");
					val3.transform.SetParent(val.transform, false);
					val3.RemoveOffset();
					var (val4, val5, _) = UIUtils.MakeButtonWithImage("Delete", val3, new Vector2((float)(i * 125 - 35), (float)(num * 160 - 35)), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 100, 100, doOutline: false);
					val5.sprite = sprite;
					var (val6, val7, _) = UIUtils.MakeButtonWithImage("Edit", val3, new Vector2((float)(i * 125 + 35), (float)(num * 160 - 35)), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 100, 100, doOutline: false);
					val7.sprite = sprite2;
					LevelDisplay display = new LevelDisplay(val, val2, (Text)(object)textComponent);
					((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
					{
						OpenDeleteUI(display.LevelInfo.LevelName);
					});
					((UnityEvent)val6.onClick).AddListener((UnityAction)delegate
					{
						LevelConfig.CurrentInfo = display.LevelInfo;
						SharerManager.TransitionToState(Home.LevelConfig);
					});
					_displays.Add(display);
					val.AddComponent<ShowButtons>().buttonParent = val3;
					val3.SetActive(false);
					val.SetActive(false);
					val2.sprite = SharerManager.Placeholder;
					((Text)textComponent).text = "Lorem Ipsum Dolor Sit";
				}
			}
			UIUtils.Label label;
			(_leftBtn, label) = UIUtils.MakeTextButton("Arrow Left", "<=", ((Component)this).gameObject, new Vector2(-375f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(100f, 100f));
			((Text)label.textComponent).fontSize = 15;
			((Text)label.textComponent).alignment = (TextAnchor)4;
			((UnityEvent)_leftBtn.onClick).AddListener((UnityAction)delegate
			{
				page--;
				((MonoBehaviour)this).StartCoroutine(RefreshPage());
			});
			UIUtils.Label label2;
			(_rightBtn, label2) = UIUtils.MakeTextButton("Arrow Right", "=>", ((Component)this).gameObject, new Vector2(375f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(100f, 100f));
			((Text)label2.textComponent).fontSize = 15;
			((Text)label2.textComponent).alignment = (TextAnchor)4;
			((UnityEvent)_rightBtn.onClick).AddListener((UnityAction)delegate
			{
				page++;
				((MonoBehaviour)this).StartCoroutine(RefreshPage());
			});
			SetupDeleteUI();
		}

		private void SetupDeleteUI()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: 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_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Expected O, but got Unknown
			<>c__DisplayClass14_0 CS$<>8__locals0 = new <>c__DisplayClass14_0();
			CS$<>8__locals0.<>4__this = this;
			_deleteUI = new GameObject("Delete UI");
			_deleteUI.transform.SetParent(((Component)this).transform, false);
			_deleteUI.RemoveOffset();
			Image val = UIUtils.MakeImage("Bg", _deleteUI, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(10000f, 10000f));
			val.sprite = ResourceUtils.LoadSpriteResource("Sharer.config_bg", (FilterMode)1);
			_bg = ((Component)val).transform;
			GameObject val2 = new GameObject("Content");
			val2.transform.SetParent(_deleteUI.transform, false);
			val2.RemoveOffset();
			UIUtils.Label label;
			(_nameField, label) = UIUtils.MakeTextbox("Name Input", val2, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 1000f, 80f);
			((Component)label).transform.localScale = Vector3.one;
			((Text)label.textComponent).fontSize = 16;
			RectTransform val3 = (RectTransform)((Component)label).transform;
			val3.sizeDelta /= 3f;
			_changeTitle = (Text)(object)UIUtils.MakeLabel("Title", val2, new Vector2(0f, 140f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_changeTitle.fontSize = 20;
			_changeTitle.alignment = (TextAnchor)4;
			UIUtils.Label label2;
			(CS$<>8__locals0.cancel, label2) = UIUtils.MakeTextButton("Cancel", "Cancel", val2, new Vector2(-70f, -140f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(360f, 80f));
			((Text)label2.textComponent).fontSize = 18;
			((UnityEvent)CS$<>8__locals0.cancel.onClick).AddListener((UnityAction)delegate
			{
				CS$<>8__locals0.<>4__this._deleteUI.SetActive(false);
			});
			UIUtils.Label label3;
			(_confirm, label3) = UIUtils.MakeTextButton("Confirm", "Delete", val2, new Vector2(70f, -140f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(360f, 80f));
			((Text)label3.textComponent).fontSize = 18;
			((UnityEvent)_confirm.onClick).AddListener((UnityAction)delegate
			{
				((Selectable)CS$<>8__locals0.cancel).interactable = false;
				((Selectable)CS$<>8__locals0.<>4__this._confirm).interactable = false;
				((MonoBehaviour)CS$<>8__locals0.<>4__this).StartCoroutine(RequestManager.SendDeleteRequest(CS$<>8__locals0.<>4__this._currentDeleteName, delegate(bool b)
				{
					((MonoBehaviour)CS$<>8__locals0.<>4__this).StartCoroutine(OnComplete(b));
				}));
			});
			((UnityEvent<string>)(object)_nameField.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				((Selectable)CS$<>8__locals0.<>4__this._confirm).interactable = s == CS$<>8__locals0.<>4__this._currentDeleteName;
			});
			_deleteUI.SetActive(false);
			[IteratorStateMachine(typeof(<>c__DisplayClass14_0.<<SetupDeleteUI>g__OnComplete|3>d))]
			IEnumerator OnComplete(bool b)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <>c__DisplayClass14_0.<<SetupDeleteUI>g__OnComplete|3>d(0)
				{
					<>4__this = CS$<>8__locals0,
					b = b
				};
			}
		}

		private void OpenDeleteUI(string levelName)
		{
			_bg.SetAsFirstSibling();
			_currentDeleteName = levelName;
			_changeTitle.text = "Enter '" + levelName + "' to confirm:";
			_nameField.text = "";
			((Selectable)_confirm).interactable = false;
			_deleteUI.SetActive(true);
		}

		public override void OnOpen()
		{
			page = 0;
			((MonoBehaviour)this).StartCoroutine(RefreshPage());
		}

		[IteratorStateMachine(typeof(<RefreshPage>d__17))]
		private IEnumerator RefreshPage()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RefreshPage>d__17(0)
			{
				<>4__this = this
			};
		}
	}
}
namespace Architect.Sharer.Info
{
	public class LevelInfo
	{
		public enum LevelTag
		{
			Platforming,
			Multiplayer,
			Gauntlets,
			Areas,
			Troll,
			Bosses,
			Minigames
		}

		public enum LevelDuration
		{
			Tiny,
			Short,
			Medium,
			Long,
			None
		}

		public enum LevelDifficulty
		{
			None,
			Easy,
			Medium,
			Hard,
			ExtraHard
		}

		public string LevelId;

		public string CreatorId;

		public string CreatorName;

		public string LevelName;

		public string LevelDesc;

		public string IconURL;

		public bool HasSave;

		public int DownloadCount;

		public int LikeCount;

		public LevelDifficulty Difficulty = LevelDifficulty.None;

		public LevelDuration Duration = LevelDuration.None;

		public List<LevelTag> Tags = new List<LevelTag>();

		public string Uploaded;

		public string Updated;

		public bool Liked;
	}
	public static class TagMethods
	{
		public static string GetLabel(this LevelInfo.LevelDuration duration)
		{
			if (1 == 0)
			{
			}
			string result = duration switch
			{
				LevelInfo.LevelDuration.Tiny => "< 10 mins", 
				LevelInfo.LevelDuration.Short => "10–30 mins", 
				LevelInfo.LevelDuration.Medium => "30–60 mins", 
				LevelInfo.LevelDuration.Long => "60+ mins", 
				LevelInfo.LevelDuration.None => "N/A", 
				_ => throw new ArgumentOutOfRangeException("duration", duration, null), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetLabel(this LevelInfo.LevelDifficulty difficulty)
		{
			if (1 == 0)
			{
			}
			string result = difficulty switch
			{
				LevelInfo.LevelDifficulty.None => "N/A", 
				LevelInfo.LevelDifficulty.Easy => "Easy", 
				LevelInfo.LevelDifficulty.Medium => "Medium", 
				LevelInfo.LevelDifficulty.Hard => "Hard", 
				LevelInfo.LevelDifficulty.ExtraHard => "Extreme", 
				_ => throw new ArgumentOutOfRangeException("difficulty", difficulty, null), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetLabel(this LevelInfo.LevelTag tag)
		{
			if (1 == 0)
			{
			}
			string result = tag switch
			{
				LevelInfo.LevelTag.Platforming => "Platforming", 
				LevelInfo.LevelTag.Minigames => "Minigames", 
				LevelInfo.LevelTag.Multiplayer => "Multiplayer", 
				LevelInfo.LevelTag.Gauntlets => "Gauntlets", 
				LevelInfo.LevelTag.Areas => "Areas", 
				LevelInfo.LevelTag.Troll => "Troll", 
				LevelInfo.LevelTag.Bosses => "Bosses", 
				_ => throw new ArgumentOutOfRangeException("tag", tag, null), 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class UserInfo
	{
		[Serializable]
		private class Token
		{
			public string token;
		}

		[Serializable]
		private class Key
		{
			public string key;
		}

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

			private object <>2__current;

			public UserInfo <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this.IsSetup)
					{
						return false;
					}
					<>2__current = RequestManager.GetUserInfo(<>4__this, delegate(string user, string desc, string pfp)
					{
						<>4__this.Username = user;
						<>4__this.Description = desc;
						<>4__this.PfpUrl = pfp;
						<>4__this.IsSetup = true;
					});
					<>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();
			}
		}

		public string UserID;

		public bool UsingToken;

		public string Username;

		public string Description;

		public string PfpUrl;

		public bool IsSetup;

		public UserInfo(string userId, bool usingToken)
		{
			UserID = userId;
			UsingToken = usingToken;
			base..ctor();
		}

		public string GetRequestJson()
		{
			return UsingToken ? JsonConvert.SerializeObject((object)new Token
			{
				token = UserID
			}) : JsonConvert.SerializeObject((object)new Key
			{
				key = UserID
			});
		}

		[IteratorStateMachine(typeof(<Setup>d__10))]
		public IEnumerator Setup()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Setup>d__10(0)
			{
				<>4__this = this
			};
		}
	}
}
namespace Architect.Prefabs
{
	public static class PrefabManager
	{
		[CompilerGenerated]
		private sealed class <LoadScene>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string sceneName;

			private string <current>5__1;

			private Scene <scene>5__2;

			private AsyncOperation <unload2>5__3;

			private GameObject <sm>5__4;

			private SpriteRenderer <sr>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<current>5__1 = null;
				<unload2>5__3 = null;
				<sm>5__4 = null;
				<sr>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
					<current>5__1 = GameManager.instance.sceneName;
					<scene>5__2 = SceneManager.CreateScene(sceneName);
					SceneManager.SetActiveScene(<scene>5__2);
					<unload2>5__3 = SceneManager.UnloadSceneAsync(<current>5__1);
					if (<unload2>5__3 == null)
					{
						goto IL_0096;
					}
				}
				if (!<unload2>5__3.isDone)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_0096;
				IL_0096:
				<sm>5__4 = SceneUtils.CreateSceneManager();
				<sm>5__4.transform.position = new Vector3(100f, 100f, 1f);
				<sm>5__4.transform.localScale = Vector3.one;
				<sr>5__5 = <sm>5__4.AddComponent<SpriteRenderer>();
				<sr>5__5.sprite = PrefabIcon;
				EditManager.NoclipPos.x = 100f;
				EditManager.NoclipPos.y = 100f;
				Extensions.SetPosition2D(HeroController.instance.transform, new Vector2(100f, 100f));
				Extensions.SetPosition2D(((Component)GameCameras.instance.mainCamera).transform, 100f, 100f);
				Extensions.SetPosition2D(((Component)GameCameras.instance.cameraTarget).transform, 100f, 100f);
				GameCameras.instance.cameraTarget.SceneInit();
				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 static readonly Dictionary<string, LevelData> Prefabs = new Dictionary<string, LevelData>();

		public static bool InPrefabScene;

		public static string Last;

		public static readonly Sprite PrefabIcon = ResourceUtils.LoadSpriteResource("prefab", (FilterMode)1, default(Vector4), 256f);

		private static string _oldScene;

		private static Vector3 _oldPos;

		public static void Init()
		{
			PrefabObject.Init();
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				if (!GameManager.instance.sceneName.StartsWith("Prefab_"))
				{
					InPrefabScene = false;
					ScriptEditorUI.ToggleParent.SetActive(true);
				}
			});
		}

		public static void Toggle(string prefabName)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			Last = prefabName;
			if (GameManager.instance.isPaused)
			{
				((MonoBehaviour)GameManager.instance).StartCoroutine(GameManager.instance.PauseGameToggle(false));
				GameManager.instance.SetPausedState(false);
			}
			InPrefabScene = !InPrefabScene;
			GameManager.instance.entryGateName = "";
			if (!InPrefabScene)
			{
				ScriptEditorUI.ToggleParent.SetActive(true);
				EditManager.NoclipPos = _oldPos;
				GameManager.instance.ChangeToScene(_oldScene, "", 0f);
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			foreach (GameObject val in rootGameObjects)
			{
				TransitionPoint[] componentsInChildren = val.GetComponentsInChildren<TransitionPoint>();
				foreach (TransitionPoint val2 in componentsInChildren)
				{
					((Component)val2).gameObject.SetActive(false);
				}
			}
			ScriptManager.IsLocal = true;
			ScriptEditorUI.ToggleParent.SetActive(false);
			_oldScene = GameManager.instance.sceneName;
			_oldPos = HeroController.instance.transform.position;
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(LoadScene("Prefab_" + prefabName));
		}

		[IteratorStateMachine(typeof(<LoadScene>d__8))]
		private static IEnumerator LoadScene(string sceneName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadScene>d__8(0)
			{
				sceneName = sceneName
			};
		}
	}
	public class PrefabObject : PlaceableObject
	{
		private static GameObject _prefabObject;

		public readonly string Name;

		public static void Init()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_prefabObject = new GameObject("[Architect] Prefab Spawner");
			_prefabObject.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_prefabObject);
			_prefabObject.AddComponent<Prefab>();
		}

		public PrefabObject(string name)
			: this(name, PrefabManager.Prefabs[name] = StorageManager.LoadScene("Prefab_" + name))
		{
		}

		public PrefabObject(string name, LevelData data)
			: base(name + " (Prefab)", "prefab_" + name, "References a prefab, changes to the prefab will\nupdate every copy of this object.\n\nHold Left Alt when placing to disconnect the objects from the prefab.", null, preview: true, PrefabManager.PrefabIcon)
		{
			FinishSetup(_prefabObject);
			PostSpawnAction = Setup;
			Name = name;
			RefreshConfig(data);
			ReceiverGroup = Architect.Objects.Groups.ReceiverGroup.Prefab;
			RotateAction = Rotate;
			FlipAction = Flip;
			ScaleAction = Scale;
		}

		public void RefreshConfig(LevelData data)
		{
			ConstantBlock[] array = data.ScriptBlocks.OfType<ConstantBlock>().ToArray();
			ConstantBlock[] array2 = array;
			foreach (ConstantBlock constantBlock in array2)
			{
				foreach (KeyValuePair<string, Architect.Events.Blocks.Config.Types.ConfigValue> item in constantBlock.CurrentConfig)
				{
					item.Value.Setup(constantBlock);
				}
			}
			ConfigGroup = (from b in array
				where b.Public
				select b.GetConfigType()).Concat(Architect.Objects.Groups.ConfigGroup.Prefab).ToList();
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_0318: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKey((KeyCode)308) && first)
			{
				string text = "-" + Guid.NewGuid().ToString().Substring(0, 8);
				if (!PrefabManager.Prefabs.TryGetValue(Name, out var value))
				{
					LevelData levelData2 = (PrefabManager.Prefabs[Name] = StorageManager.LoadScene("Prefab_" + Name));
					value = levelData2;
				}
				List<ObjectPlacement> list = new List<ObjectPlacement>();
				Vector3 worldPos = EditManager.GetWorldPos(mousePosition, lockAxisApplies: true);
				worldPos.z = 0f;
				foreach (ObjectPlacement placement in value.Placements)
				{
					ObjectPlacement objectPlacement = JsonConvert.DeserializeObject<ObjectPlacement>(JsonConvert.SerializeObject((object)placement), (JsonConverter[])(object)new JsonConverter[1] { (JsonConverter)StorageManager.Opc });
					objectPlacement.ID += text;
					list.Add(objectPlacement);
					Architect.Config.Types.ConfigValue[] config = objectPlacement.Config;
					foreach (Architect.Config.Types.ConfigValue configValue in config)
					{
						if (configValue is IdConfigValue idConfigValue)
						{
							idConfigValue.Value += text;
						}
					}
					Vector3 val = placement.GetPos() + worldPos - new Vector3(100f, 100f);
					Vector3 val2 = (val - worldPos) * EditManager.CurrentScale;
					if (EditManager.CurrentlyFlipped)
					{
						val2.x = 0f - val2.x;
					}
					val = val2 + worldPos;
					val = val.RotatePointAroundPivot(worldPos, EditManager.CurrentRotation);
					objectPlacement.SetRotation(objectPlacement.GetRotation() + EditManager.CurrentRotation);
					objectPlacement.SetScale(objectPlacement.GetScale() * EditManager.CurrentScale);
					objectPlacement.SetFlipped(objectPlacement.GetFlipped() != EditManager.CurrentlyFlipped);
					objectPlacement.SetLayer(EditManager.Layer);
					objectPlacement.Move(val);
				}
				EditManager.RegisterLastPos(Vector2.op_Implicit(worldPos));
				ActionManager.PerformAction(new PlaceObjects(list));
				List<ScriptBlock> list2 = new List<ScriptBlock>();
				foreach (ScriptBlock scriptBlock2 in value.ScriptBlocks)
				{
					ScriptBlock scriptBlock = scriptBlock2.Clone(text);
					bool isLocal = ScriptManager.IsLocal;
					if (!isLocal)
					{
						ScriptManager.IsLocal = true;
					}
					PlacementManager.GetLevelData().ScriptBlocks.Add(scriptBlock);
					scriptBlock.Setup(visual: true);
					list2.Add(scriptBlock);
					if (!isLocal)
					{
						ScriptManager.IsLocal = false;
					}
				}
				{
					foreach (ScriptBlock item in list2)
					{
						item.LateSetup();
					}
					return;
				}
			}
			base.Click(mousePosition, first);
		}

		private void Setup(GameObject self)
		{
			self.GetComponent<Prefab>().id = Name;
		}

		private static void Rotate(GameObject self, float rot)
		{
			self.GetComponent<Prefab>().rot = rot;
		}

		private static void Flip(GameObject self, bool flip)
		{
			self.GetComponent<Prefab>().flip = flip;
		}

		private static void Scale(GameObject self, float scale)
		{
			self.GetComponent<Prefab>().scale = scale;
		}
	}
	public class Prefab : PreviewableBehaviour
	{
		public string id;

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

		private readonly Dictionary<string, List<ReceiveBlock>> _receivers = new Dictionary<string, List<ReceiveBlock>>();

		private readonly Dictionary<string, VarBlock> _vars = new Dictionary<string, VarBlock>();

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

		public int visibility;

		public float scale = 1f;

		public float rot;

		public bool flip;

		public void Destroy()
		{
			foreach (GameObject spawn in spawns)
			{
				Object.Destroy((Object)(object)spawn);
			}
		}

		public void ApplyConfig(string block, string value)
		{
			_constants[block] = value;
		}

		private void Start()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.instance.sceneName == "Prefab_" + id)
			{
				((Component)this).GetComponentInParent<SpriteRenderer>().color = Color.red;
				return;
			}
			if (!PrefabManager.Prefabs.TryGetValue(id, out var value))
			{
				LevelData levelData2 = (PrefabManager.Prefabs[id] = StorageManager.LoadScene("Prefab_" + id));
				value = levelData2;
			}
			foreach (ObjectPlacement placement in value.Placements)
			{
				if (isAPreview)
				{
					if (visibility == 0 || (visibility == 1 && !placement.Locked))
					{
						placement.PlaceGhost(placement.GetPos() + ((Component)this).transform.position - new Vector3(100f, 100f), store: false, ((Object)this).name).transform.SetParent(((Component)this).transform, true);
					}
					continue;
				}
				Vector3 val = placement.GetPos() + ((Component)this).transform.position - new Vector3(100f, 100f);
				Vector3 val2 = (val - ((Component)this).transform.position) * scale;
				if (flip)
				{
					val2.x = 0f - val2.x;
				}
				val = val2 + ((Component)this).transform.position;
				val = val.RotatePointAroundPivot(((Component)this).transform.position, rot);
				GameObject val3 = placement.SpawnObject(val, ((Object)this).name, rot, scale, flip);
				PlacementManager.PrefabPlacements[placement.GetId() + ((Object)this).name] = placement;
				if (Object.op_Implicit((Object)(object)val3))
				{
					PlacementManager.Objects[placement.GetId() + ((Object)this).name] = val3;
					PlacementManager.OnPlace?.Invoke(placement.GetPlacementType().GetId(), placement.GetId() + ((Object)this).name, val3);
					spawns.Add(val3);
				}
			}
			foreach (ScriptBlock scriptBlock4 in value.ScriptBlocks)
			{
				ScriptBlock scriptBlock = scriptBlock4.Clone(((Object)this).name);
				scriptBlock.Setup(visual: false);
				ScriptBlock scriptBlock2 = scriptBlock;
				ScriptBlock scriptBlock3 = scriptBlock2;
				if (!(scriptBlock3 is BroadcastBlock broadcastBlock))
				{
					if (!(scriptBlock3 is ReceiveBlock receiveBlock))
					{
						if (!(scriptBlock3 is VarBlock varBlock))
						{
							if (scriptBlock3 is ConstantBlock constantBlock && constantBlock.Public && _constants.TryGetValue(scriptBlock4.BlockId, out var value2))
							{
								constantBlock.Load(value2);
							}
						}
						else if (varBlock.Local)
						{
							_vars[((VarBlock)scriptBlock4).Id] = varBlock;
						}
					}
					else if (receiveBlock.Local)
					{
						receiveBlock.ActualEventName = ((ReceiveBlock)scriptBlock4).EventName;
						if (!_receivers.ContainsKey(receiveBlock.ActualEventName))
						{
							_receivers[receiveBlock.ActualEventName] = new List<ReceiveBlock>();
						}
						_receivers[receiveBlock.ActualEventName].Add(receiveBlock);
					}
				}
				else if (broadcastBlock.Local)
				{
					broadcastBlock.ActualEventName = ((BroadcastBlock)scriptBlock4).EventName;
					broadcastBlock.TargetPrefab = ((Component)this).gameObject;
				}
			}
			if (isAPreview)
			{
				Extensions.SetRotation2D(((Component)this).transform, rot);
				Transform transform = ((Component)this).transform;
				transform.localScale *= scale;
				if (flip)
				{
					Extensions.SetScaleX(((Component)this).transform, 0f - Extensions.GetScaleX(((Component)this).transform));
				}
			}
		}

		public object GetVar(string varId)
		{
			VarBlock value;
			return _vars.TryGetValue(varId, out value) ? value.GetValue("Value") : null;
		}

		public void Receive(string eName)
		{
			if (!_receivers.TryGetValue(eName, out var value))
			{
				return;
			}
			foreach (ReceiveBlock item in value)
			{
				item.Event("OnReceive");
			}
		}

		public void Move(Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = pos - ((Component)this).transform.position;
			foreach (GameObject spawn in spawns)
			{
				Transform transform = spawn.transform;
				transform.position += val;
			}
			((Component)this).transform.position = pos;
		}

		public void SetRotation(float r)
		{
			//IL_0025: 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)
			foreach (GameObject spawn in spawns)
			{
				spawn.transform.RotateAround(((Component)this).transform.position, new Vector3(0f, 0f, 1f), r - rot);
			}
			rot = r;
		}
	}
}
namespace Architect.Placements
{
	[JsonConverter(typeof(LevelDataConverter))]
	public class LevelData
	{
		public class LevelDataConverter : JsonConverter<LevelData>
		{
			public override void WriteJson(JsonWriter writer, LevelData value, JsonSerializer serializer)
			{
				writer.WriteStartObject();
				writer.WritePropertyName("placements");
				serializer.Serialize(writer, (object)value.Placements);
				writer.WritePropertyName("tilemap");
				serializer.Serialize(writer, (object)value.TilemapChanges);
				writer.WritePropertyName("script");
				serializer.Serialize(writer, (object)value.ScriptBlocks);
				if (value.Comments.Count > 0)
				{
					writer.WritePropertyName("comments");
					serializer.Serialize(writer, (object)value.Comments);
				}
				writer.WriteEndObject();
			}

			public override LevelData ReadJson(JsonReader reader, Type objectType, LevelData existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				if ((int)reader.TokenType == 2)
				{
					return new LevelData(serializer.Deserialize<List<ObjectPlacement>>(reader), new List<(int, int)>(), new List<ScriptBlock>(), new List<Comment>());
				}
				List<ObjectPlacement> list = new List<ObjectPlacement>();
				List<(int, int)> tilemapChanges = new List<(int, int)>();
				List<ScriptBlock> scriptBlocks = new List<ScriptBlock>();
				List<Comment> comments = new List<Comment>();
				while (reader.Read() && reader.Value is string text)
				{
					switch (text)
					{
					case "placements":
						reader.Read();
						list = serializer.Deserialize<List<ObjectPlacement>>(reader);
						break;
					case "tilemap":
						reader.Read();
						tilemapChanges = serializer.Deserialize<List<(int, int)>>(reader);
						break;
					case "script":
						reader.Read();
						scriptBlocks = serializer.Deserialize<List<ScriptBlock>>(reader);
						break;
					case "comments":
						reader.Read();
						comments = serializer.Deserialize<List<Comment>>(reader) ?? new List<Comment>();
						break;
					}
				}
				list.RemoveAll((ObjectPlacement o) => o == null);
				return new LevelData(list, tilemapChanges, scriptBlocks, comments);
			}
		}

		public readonly List<ObjectPlacement> Placements;

		public readonly List<(int, int)> TilemapChanges;

		public readonly List<ScriptBlock> ScriptBlocks;

		public readonly List<Comment> Comments;

		public LevelData(List<ObjectPlacement> placements, List<(int, int)> tilemapChanges, List<ScriptBlock> scriptBlocks, List<Comment> comments)
		{
			Placements = placements;
			TilemapChanges = tilemapChanges;
			ScriptBlocks = scriptBlocks;
			Comments = comments;
			base..ctor();
		}

		public void ToggleTile((int, int) pos)
		{
			if (!TilemapChanges.Remove(pos))
			{
				TilemapChanges.Add(pos);
			}
		}

		public void Merge(LevelData levelData)
		{
			Placements.AddRange(levelData.Placements);
			TilemapChanges.AddRange(levelData.TilemapChanges.Where(((int, int) t) => !TilemapChanges.Contains(t)));
			ScriptBlocks.AddRange(levelData.ScriptBlocks);
			Comments.AddRange(levelData.Comments);
		}

		public void Clear()
		{
			Placements.Clear();
			TilemapChanges.Clear();
			ScriptBlocks.Clear();
			Comments.Clear();
		}
	}
	[JsonConverter(typeof(ObjectPlacementConverter))]
	public class ObjectPlacement
	{
		public class PreviewObject : MonoBehaviour
		{
			public Vector3 offset;
		}

		public class ObjectPlacementConverter : JsonConverter<ObjectPlacement>
		{
			public override void WriteJson(JsonWriter writer, ObjectPlacement value, JsonSerializer serializer)
			{
				writer.WriteStartObject();
				WritePlacementInfo(writer, value, serializer);
				if (value.Broadcasters.Length != 0)
				{
					writer.WritePropertyName("events");
					serializer.Serialize(writer, (object)value.Broadcasters);
				}
				if (value.Receivers.Length != 0)
				{
					writer.WritePropertyName("listeners");
					serializer.Serialize(writer, (object)value.Receivers);
				}
				if (value.Config.Length != 0)
				{
					writer.WritePropertyName("config");
					serializer.Serialize(writer, (object)value.Config.ToDictionary((Architect.Config.Types.ConfigValue c) => c.GetTypeId(), (Architect.Config.Types.ConfigValue c) => c.SerializeValue()));
				}
				writer.WriteEndObject();
			}

			private static void WritePlacementInfo(JsonWriter writer, ObjectPlacement placement, JsonSerializer serializer)
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				writer.WritePropertyName("placement");
				writer.WriteStartObject();
				writer.WritePropertyName("id");
				writer.WriteValue(placement.GetPlacementType().GetId());
				writer.WritePropertyName("pid");
				writer.WriteValue(placement.GetId());
				writer.WritePropertyName("pos");
				serializer.Serialize(writer, (object)placement.GetPos());
				writer.WritePropertyName("flipped");
				writer.WriteValue(placement.IsFlipped());
				writer.WritePropertyName("locked");
				writer.WriteValue(placement.Locked);
				writer.WritePropertyName("rotation");
				writer.WriteValue(placement.GetRotation());
				writer.WritePropertyName("scale");
				writer.WriteValue(placement.GetScale());
				writer.WritePropertyName("layer");
				writer.WriteValue(placement._layer);
				writer.WriteEndObject();
			}

			public override ObjectPlacement ReadJson(JsonReader reader, Type objectType, ObjectPlacement existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Unknown result type (might be due to invalid IL or missing references)
				//IL_0326: Invalid comparison between Unknown and I4
				//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cc: Invalid comparison between Unknown and I4
				//IL_036d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0246: Unknown result type (might be due to invalid IL or missing references)
				//IL_024b: Unknown result type (might be due to invalid IL or missing references)
				string key = "";
				string text = null;
				Vector3 position = Vector3.zero;
				bool flipped = true;
				float rotation = 0f;
				float scale = 1f;
				int layer = 0;
				bool locked = false;
				(string, string)[] broadcasters = Array.Empty<(string, string)>();
				(string, string, int)[] receivers = Array.Empty<(string, string, int)>();
				Architect.Config.Types.ConfigValue[] config = Array.Empty<Architect.Config.Types.ConfigValue>();
				reader.Read();
				while ((int)reader.TokenType == 4)
				{
					switch (reader.Value as string)
					{
					case "placement":
						reader.Read();
						reader.Read();
						while ((int)reader.TokenType == 4)
						{
							switch (reader.Value as string)
							{
							case "id":
								reader.ReadAsString();
								key = reader.Value as string;
								break;
							case "pid":
								reader.ReadAsString();
								text = reader.Value as string;
								break;
							case "pos":
								reader.Read();
								position = serializer.Deserialize<Vector3>(reader);
								break;
							case "flipped":
								reader.ReadAsBoolean();
								flipped = (bool)reader.Value;
								break;
							case "locked":
								reader.ReadAsBoolean();
								locked = (bool)reader.Value;
								break;
							case "rotation":
								reader.ReadAsDouble();
								rotation = (float)(double)reader.Value;
								break;
							case "scale":
								reader.ReadAsDouble();
								scale = (float)(double)reader.Value;
								break;
							case "layer":
								reader.ReadAsInt32();
								layer = (int)reader.Value;
								break;
							}
							reader.Read();
						}
						break;
					case "events":
						reader.Read();
						broadcasters = serializer.Deserialize<(string, string)[]>(reader);
						break;
					case "listeners":
						reader.Read();
						receivers = serializer.Deserialize<(string, string, int)[]>(reader);
						break;
					case "config":
						reader.Read();
						config = DeserializeConfig(serializer.Deserialize<Dictionary<string, string>>(reader));
						break;
					}
					reader.Read();
				}
				if (text == null)
				{
					text = Guid.NewGuid().ToString().Substring(0, 8);
				}
				if (!PlaceableObject.RegisteredObjects.TryGetValue(key, out var value))
				{
					return null;
				}
				return new ObjectPlacement(value, position, text, flipped, rotation, scale, locked, layer, broadcasters, receivers, config);
			}

			private static Architect.Config.Types.ConfigValue[] DeserializeConfig(Dictionary<string, string> data)
			{
				List<Architect.Config.Types.ConfigValue> list = new List<Architect.Config.Types.ConfigValue>();
				try
				{
					list.AddRange(from pair in data
						select Architect.Config.ConfigurationManager.DeserializeConfigValue(pair.Key, pair.Value) into cfg
						where cfg != null
						select cfg);
					return list.ToArray();
				}
				catch (Exception)
				{
					return Array.Empty<Architect.Config.Types.ConfigValue>();
				}
			}
		}

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private PlaceableObject <type>P;

		private static readonly Color DefaultColour = new Color(1f, 1f, 1f, 0.5f);

		private static readonly Color DraggedColour = new Color(0.2f, 1f, 0.2f, 0.5f);

		private static readonly Color HoverColour = new Color(0.2f, 0.2f, 1f, 0.5f);

		public string ID;

		private Color? _previewColour;

		private GameObject _previewObject;

		private SpriteRenderer _previewRenderer;

		private float _rotation;

		private float _scale;

		private bool _flipped;

		public bool Locked;

		public readonly (string, string)[] Broadcasters;

		public readonly (string, string, int)[] Receivers;

		public readonly Architect.Config.Types.ConfigValue[] Config;

		private Vector3 _dragOffset;

		private Vector3 _position;

		private Vector3 _offset;

		private Vector3 _oldPos;

		private bool _setColour;

		private int _layer;

		public ObjectPlacement(PlaceableObject type, Vector3 position, string id, bool flipped, float rotation, float scale, bool locked, int layer, (string, string)[] broadcasters, (string, string, int)[] receivers, Architect.Config.Types.ConfigValue[] config)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			<type>P = type;
			ID = id;
			_rotation = rotation;
			_scale = scale;
			_flipped = flipped;
			Locked = locked;
			Broadcasters = broadcasters;
			Receivers = receivers;
			Config = config;
			_position = position;
			_layer = layer;
			base..ctor();
		}

		public bool Touching(Vector3 mousePos)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0070: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_previewObject) || !Object.op_Implicit((Object)(object)_previewRenderer) || !Object.op_Implicit((Object)(object)_previewRenderer.sprite))
			{
				return false;
			}
			Vector3 worldPos = EditManager.GetWorldPos(mousePos, lockAxisApplies: false, _previewObject.transform.position.z);
			Bounds bounds = _previewRenderer.sprite.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			float num = size.x / 2f * Mathf.Abs(Extensions.GetScaleX(_previewObject.transform));
			float num2 = size.y / 2f * Mathf.Abs(Extensions.GetScaleY(_previewObject.transform));
			Vector3 position = _previewObject.transform.position;
			Quaternion rotation = _previewObject.transform.rotation;
			Vector3 val = Quaternion.Inverse(rotation) * (worldPos - position);
			return Mathf.Abs(val.x) <= num && Mathf.Abs(val.y) <= num2;
		}

		public bool IsWithinZone(Vector2 pos1, Vector2 pos2)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_previewObject) || IsLocked())
			{
				return false;
			}
			bool flag = (_position.x > pos1.x && _position.x < pos2.x) || (_position.x < pos1.x && _position.x > pos2.x);
			bool flag2 = (_position.y > pos1.y && _position.y < pos2.y) || (_position.y < pos1.y && _position.y > pos2.y);
			return flag && flag2;
		}

		public string GetId()
		{
			return ID;
		}

		public PlaceableObject GetPlacementType()
		{
			return <type>P;
		}

		public Vector3 GetPos()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _position;
		}

		public bool IsFlipped()
		{
			return _flipped;
		}

		public float GetRotation()
		{
			return _rotation;
		}

		public void SetRotation(float rot)
		{
			_rotation = rot;
		}

		public bool GetFlipped()
		{
			return _flipped;
		}

		public void SetFlipped(bool flip)
		{
			_flipped = flip;
		}

		public void SetScale(float sc)
		{
			_scale = sc;
		}

		public float GetScale()
		{
			return _scale;
		}

		public bool IsLocked()
		{
			return Locked || !IsCurrentLayer();
		}

		public bool IsCurrentLayer()
		{
			return _layer == EditManager.Layer;
		}

		private bool ShowCurrentLayer()
		{
			return IsCurrentLayer() || EditManager.FlippedLayers.Contains(_layer) != EditManager.ShowLayersByDefault;
		}

		public void SetLayer(int layer)
		{
			_layer = layer;
		}

		public void ToggleLocked()
		{
			Locked = !Locked;
			RefreshLockColour();
		}

		public void RefreshLockColour()
		{
			//IL_0021: 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)
			if (Object.op_Implicit((Object)(object)_previewRenderer))
			{
				SpriteRenderer previewRenderer = _previewRenderer;
				Color color = _previewRenderer.color;
				float? num = ((!ShowCurrentLayer()) ? 0f : (IsLocked() ? 0.2f : 0.5f));
				previewRenderer.color = Extensions.Where(color, (float?)null, (float?)null, (float?)null, num);
			}
		}

		public void SetDraggedColour()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_previewRenderer))
			{
				ClearColour();
				_setColour = true;
				_previewColour = _previewRenderer.color;
				_previewRenderer.color = DraggedColour;
			}
		}

		public void SetHoverColour()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_previewRenderer))
			{
				ClearColour();
				_setColour = true;
				_previewColour = _previewRenderer.color;
				_previewRenderer.color = HoverColour;
			}
		}

		public void ClearColour()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (_setColour)
			{
				_setColour = false;
				if (Object.op_Implicit((Object)(object)_previewRenderer))
				{
					_previewRenderer.color = (Color)(((??)_previewColour) ?? DefaultColour);
				}
			}
		}

		public void StartMove(Vector3 cursorWorldPos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			_dragOffset = _position - cursorWorldPos;
			_oldPos = _position;
		}

		public Vector3 FinishMove()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			_dragOffset = Vector3.zero;
			return _oldPos;
		}

		public void Move(Vector3 newWorldPos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			_position = newWorldPos + _dragOffset;
			if (Object.op_Implicit((Object)(object)_previewObject))
			{
				Transform transform = _previewObject.transform;
				Vector3 val = _position + _offset;
				float? num = _previewObject.transform.position.z;
				transform.position = Extensions.Where(val, (float?)null, (float?)null, num);
			}
		}

		public GameObject PlaceGhost(Vector3 pos = default(Vector3), bool store = true, string extraId = null)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			float num = _rotation + <type>P.Rotation;
			if (pos == default(Vector3))
			{
				pos = _position;
			}
			else
			{
				pos.z = _position.z;
			}
			GameObject val = new GameObject("[Architect] " + <type>P.GetName() + " (" + ID + ") Preview");
			val.transform.localScale = <type>P.LossyScale;
			_previewObject = val;
			_previewRenderer = _previewObject.AddComponent<SpriteRenderer>();
			_previewRenderer.color = DefaultColour;
			_previewRenderer.sprite = <type>P.Sprite;
			Transform transform = _previewObject.transform;
			transform.localScale *= _scale;
			Extensions.SetRotation2D(_previewObject.transform, num + <type>P.ChildRotation + (float)<type>P.Tk2dRotation);
			if (<type>P.Preview)
			{
				GameObject val2 = SpawnObject(default(Vector3), extraId);
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.transform.SetParent(_previewObject.transform);
					Renderer[] componentsInChildren = val2.GetComponentsInChildren<Renderer>();
					foreach (Renderer val3 in componentsInChildren)
					{
						val3.enabled = false;
					}
					PreviewableBehaviour[] componentsInChildren2 = val2.GetComponentsInChildren<PreviewableBehaviour>();
					foreach (PreviewableBehaviour previewableBehaviour in componentsInChildren2)
					{
						previewableBehaviour.isAPreview = true;
					}
					val2.SetActive(true);
					val2.transform.localPosition = Vector3.zero;
					val2.transform.localScale = Vector3.one;
				}
			}
			_offset = PreviewUtils.FixPreview(_previewRenderer, <type>P, _flipped, num, _scale);
			_previewObject.transform.position = pos + _offset;
			_previewObject.AddComponent<PreviewObject>().offset = _offset;
			foreach (Architect.Config.Types.ConfigValue item in Config.OrderBy((Architect.Config.Types.ConfigValue configVal) => configVal.GetPriority()))
			{
				item.SetupPreview(_previewObject, Architect.Config.ConfigurationManager.PreviewContext.Placement);
			}
			RefreshLockColour();
			if (store)
			{
				PlacementManager.Objects[ID] = _previewObject;
			}
			return _previewObject;
		}

		public GameObject SpawnObject(Vector3 pos = default(Vector3), string extraId = null, float extraRot = 0f, float extraScale = 1f, bool extraFlip = false)
		{
			//IL_005f: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)<type>P.Prefab))
			{
				ArchitectPlugin.Logger.LogError((object)("Error - Prefab of " + <type>P.GetName() + " is missing, cannot spawn"));
				return null;
			}
			string text = ID;
			if (extraId != null)
			{
				text += extraId;
			}
			if (pos == default(Vector3))
			{
				pos = _position;
			}
			else
			{
				pos.z = _position.z;
			}
			bool activeSelf = <type>P.Prefab.activeSelf;
			<type>P.Prefab.SetActive(false);
			GameObject val = Object.Instantiate<GameObject>(<type>P.Prefab, pos, <type>P.Prefab.transform.rotation);
			if (activeSelf)
			{
				<type>P.Prefab.SetActive(true);
			}
			((Object)val).name = "[Architect] " + <type>P.GetName() + " (" + text + ")";
			FixId<int>(val, text);
			FixId<bool>(val, text);
			<type>P.PostSpawnAction?.Invoke(val);
			if (<type>P.FlipAction != null)
			{
				<type>P.FlipAction(val, _flipped != extraFlip);
			}
			else if (_flipped != extraFlip)
			{
				Extensions.SetScaleX(val.transform, 0f - Extensions.GetScaleX(val.transform));
			}
			if (<type>P.RotateAction != null)
			{
				<type>P.RotateAction(val, _rotation + extraRot);
			}
			else
			{
				Extensions.SetRotation2D(val.transform, _rotation + Extensions.GetRotation2D(val.transform) + extraRot);
			}
			if (<type>P.ScaleAction != null)
			{
				<type>P.ScaleAction(val, _scale * extraScale);
			}
			else
			{
				Transform transform = val.transform;
				transform.localScale *= _scale * extraScale;
			}
			foreach (Architect.Config.Types.ConfigValue item in from configVal in Config
				where configVal.GetPriority() < 0
				orderby configVal.GetPriority()
				select configVal)
			{
				item.Setup(val, extraId);
			}
			val.SetActive(true);
			(string, string, int)[] receivers = Receivers;
			for (int i = 0; i < receivers.Length; i++)
			{
				(string, string, int) tuple = receivers[i];
				LegacyReceiver legacyReceiver = val.AddComponent<LegacyReceiver>();
				legacyReceiver.eventName = tuple.Item1.ToLower();
				legacyReceiver.ReceiverType = EventManager.GetReceiverType(tuple.Item2);
				legacyReceiver.requiredCalls = tuple.Item3;
				EventManager.RegisterReceiver(legacyReceiver);
			}
			(string, string)[] broadcasters = Broadcasters;
			for (int j = 0; j < broadcasters.Length; j++)
			{
				(string, string) tuple2 = broadcasters[j];
				LegacyBroadcaster legacyBroadcaster = val.AddComponent<LegacyBroadcaster>();
				legacyBroadcaster.triggerName = tuple2.Item1;
				legacyBroadcaster.eventName = tuple2.Item2.ToLower();
			}
			foreach (Architect.Config.Types.ConfigValue item2 in from configVal in Config
				where configVal.GetPriority() >= 0
				orderby configVal.GetPriority()
				select configVal)
			{
				item2.Setup(val, extraId);
			}
			return val;
		}

		public void FixId<T>(GameObject obj, string cId) where T : IEquatable<T>
		{
			PersistentItem<T> component = obj.GetComponent<PersistentItem<T>>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.ItemData.ID = cId;
			}
		}

		public void Destroy()
		{
			if (Object.op_Implicit((Object)(object)_previewObject))
			{
				Object.Destroy((Object)(object)_previewObject);
			}
			PlacementManager.GetLevelData().Placements.Remove(this);
			PlacementManager.Objects.Remove(ID);
		}
	}
	public static class PlacementManager
	{
		private static string _sceneName;

		private static LevelData _levelData;

		private static LevelData _globalData;

		private static tk2dTileMap _tileMap;

		public static readonly Dictionary<string, GameObject> Objects = new Dictionary<string, GameObject>();

		public static readonly Dictionary<string, ObjectPlacement> PrefabPlacements = new Dictionary<string, ObjectPlacement>();

		public static Action<string, string, GameObject> OnPlace;

		public static LevelData GetLevelData()
		{
			VerifyLevelData();
			return _levelData;
		}

		public static LevelData GetGlobalData()
		{
			VerifyLevelData();
			return _globalData;
		}

		public static void VerifyLevelData()
		{
			string sceneName = GameManager.instance.sceneName;
			if (!(_sceneName == sceneName))
			{
				if (EditManager.IsEditing && _sceneName != "Invalid")
				{
					StorageManager.SaveScene(_sceneName, _levelData);
					StorageManager.SaveScene("Global", _globalData);
				}
				_sceneName = sceneName;
				_levelData = StorageManager.LoadScene(sceneName);
				_globalData = StorageManager.LoadScene("Global");
			}
		}

		public static tk2dTileMap GetTilemap()
		{
			if (!Object.op_Implicit((Object)(object)_tileMap))
			{
				_tileMap = Object.FindAnyObjectByType<tk2dTileMap>();
			}
			return _tileMap;
		}

		public static ObjectPlacement GetPlacement(string id)
		{
			ObjectPlacement objectPlacement = _levelData.Placements.FirstOrDefault((ObjectPlacement o) => o.GetId() == id);
			if (objectPlacement == null && PrefabPlacements.TryGetValue(id, out var value))
			{
				return value;
			}
			return objectPlacement;
		}

		public static void InvalidateScene()
		{
			_sceneName = "Invalid";
		}

		private static void LoadLevel(string sceneName)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			VerifyLevelData();
			PrefabManager.Prefabs.Clear();
			PrefabPlacements.Clear();
			LevelData modData = MapLoader.GetModData("Global");
			LevelData modData2 = MapLoader.GetModData(sceneName);
			EventManager.ResetReceivers();
			PlayerHook.PlayerListeners.Clear();
			AbilityObjects.ActiveCrystals.Clear();
			AbilityObjects.RefreshCrystalUI();
			Objects.Clear();
			foreach (ScriptBlock value in ScriptManager.Blocks.Values)
			{
				value.DestroyObject();
			}
			foreach (GameObject value2 in ScriptManager.Links.Values)
			{
				Object.Destroy((Object)(object)value2);
			}
			ScriptManager.Blocks.Clear();
			if (modData2 != null)
			{
				foreach (ObjectPlacement placement in modData2.Placements)
				{
					GameObject val = placement.SpawnObject();
					if (Object.op_Implicit((Object)(object)val))
					{
						Objects[placement.GetId()] = val;
						OnPlace?.Invoke(placement.GetPlacementType().GetId(), placement.GetId(), val);
					}
				}
			}
			foreach (ObjectPlacement placement2 in _levelData.Placements)
			{
				if (EditManager.IsEditing)
				{
					placement2.PlaceGhost();
					continue;
				}
				GameObject val2 = placement2.SpawnObject();
				if (Object.op_Implicit((Object)(object)val2))
				{
					Objects[placement2.GetId()] = val2;
					OnPlace?.Invoke(placement2.GetPlacementType().GetId(), placement2.GetId(), val2);
				}
			}
			if (!SceneUtils.CustomScenes.ContainsKey(sceneName))
			{
				tk2dTileMap tilemap = GetTilemap();
				if (Object.op_Implicit((Object)(object)tilemap))
				{
					if (modData2 != null && !Extensions.IsNullOrEmpty<(int, int)>((ICollection<(int, int)>)modData2.TilemapChanges))
					{
						foreach (var (num, num2) in modData2.TilemapChanges)
						{
							try
							{
								if (tilemap.GetTile(num, num2, 0) == -1)
								{
									tilemap.SetTile(num, num2, 0, 0);
								}
								else
								{
									tilemap.ClearTile(num, num2, 0);
								}
							}
							catch (Exception)
							{
							}
						}
					}
					if (!Extensions.IsNullOrEmpty<(int, int)>((ICollection<(int, int)>)_levelData.TilemapChanges))
					{
						foreach (var (num3, num4) in _levelData.TilemapChanges)
						{
							try
							{
								if (tilemap.GetTile(num3, num4, 0) == -1)
								{
									tilemap.SetTile(num3, num4, 0, 0);
								}
								else
								{
									tilemap.ClearTile(num3, num4, 0);
								}
							}
							catch (Exception)
							{
							}
						}
						tilemap.Build();
					}
				}
			}
			bool isLocal = ScriptManager.IsLocal;
			ScriptManager.IsLocal = true;
			if (modData2 != null)
			{
				foreach (ScriptBlock scriptBlock in modData2.ScriptBlocks)
				{
					scriptBlock.Setup(visual: false);
				}
			}
			foreach (ScriptBlock scriptBlock2 in _levelData.ScriptBlocks)
			{
				scriptBlock2.Setup(EditManager.IsEditing);
			}
			foreach (ScriptBlock scriptBlock3 in _levelData.ScriptBlocks)
			{
				scriptBlock3.LateSetup();
			}
			ScriptManager.IsLocal = false;
			if (modData != null)
			{
				foreach (ScriptBlock scriptBlock4 in modData.ScriptBlocks)
				{
					scriptBlock4.Setup(visual: false);
				}
			}
			foreach (ScriptBlock scriptBlock5 in _globalData.ScriptBlocks)
			{
				scriptBlock5.Setup(EditManager.IsEditing);
			}
			foreach (ScriptBlock scriptBlock6 in _globalData.ScriptBlocks)
			{
				scriptBlock6.LateSetup();
			}
			ScriptManager.IsLocal = isLocal;
			if (EditManager.IsEditing)
			{
				ScriptEditorUI.LoadComments();
			}
		}

		public static void Init()
		{
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				if (PreloadManager.HasPreloaded)
				{
					LoadLevel(GameManager.instance.sceneName);
				}
			});
		}

		[CanBeNull]
		public static ObjectPlacement FindObject(Vector3 mousePos, int includeLocked = 0)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return GetLevelData().Placements.FirstOrDefault((ObjectPlacement placement) => placement.IsCurrentLayer() && (includeLocked == 1 || placement.Locked == (includeLocked == 2)) && placement.Touching(mousePos));
		}

		public static bool TryGetValue(string path, out GameObject obj)
		{
			if (!Objects.TryGetValue(path, out obj))
			{
				return false;
			}
			ObjectHook component = obj.GetComponent<ObjectHook>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.FindObject();
				if (Object.op_Implicit((Object)(object)component.o))
				{
					obj = component.o;
				}
			}
			return true;
		}
	}
}
namespace Architect.Objects
{
	public abstract class SelectableObject
	{
		[CompilerGenerated]
		private sealed class <EnsureLoaded>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SelectableObject <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>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();
			}
		}

		public bool DisableTransformations;

		public abstract string GetName();

		[CanBeNull]
		public abstract string GetDescription();

		public abstract void Click(Vector3 mousePosition, bool first);

		public virtual void RightClick(Vector3 mousePosition)
		{
		}

		public virtual void Release()
		{
		}

		[IteratorStateMachine(typeof(<EnsureLoaded>d__5))]
		public virtual IEnumerator EnsureLoaded()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnsureLoaded>d__5(0)
			{
				<>4__this = this
			};
		}

		public abstract Sprite GetUISprite();
	}
}
namespace Architect.Objects.Tools
{
	public class BlankObject : ToolObject
	{
		public static readonly BlankObject Instance = new BlankObject();

		public BlankObject()
			: base("blank", Settings.Blank, -8)
		{
		}

		public override string GetName()
		{
			return "";
		}

		public override string GetDescription()
		{
			return "";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
		}
	}
	public class CursorObject : ToolObject
	{
		[CompilerGenerated]
		private sealed class <ClearCursorInfoLabel>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private int <n>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					_lastNum++;
					<n>5__1 = _lastNum;
					<>2__current = (object)new WaitForSeconds(10f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (_lastNum == <n>5__1)
					{
						((Text)EditorUI.ObjectIdLabel.textComponent).text = "";
					}
					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 static readonly CursorObject Instance = new CursorObject();

		private static int _lastNum;

		public override bool Highlight => true;

		public CursorObject()
			: base("cursor", Settings.Cursor, -1)
		{
		}

		public override string GetName()
		{
			return "Cursor";
		}

		public override string GetDescription()
		{
			return "Click a placed object to see its ID.\n\nRight click a placed object to add its block to the Script Editor.\n\nClick a spot to see its position.";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			ObjectPlacement objectPlacement = PlacementManager.FindObject(mousePosition);
			string text;
			if (objectPlacement == null)
			{
				Vector3 worldPos = EditManager.GetWorldPos(mousePosition);
				text = $"X: {worldPos.x}, Y: {worldPos.y}";
			}
			else
			{
				text = objectPlacement.GetPlacementType().GetName() + " ID: " + objectPlacement.GetId();
			}
			((Text)EditorUI.ObjectIdLabel.textComponent).text = text;
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(ClearCursorInfoLabel());
		}

		public override void RightClick(Vector3 mousePosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ObjectPlacement objectPlacement = PlacementManager.FindObject(mousePosition);
			if (objectPlacement != null)
			{
				ScriptManager.AddToScript(objectPlacement);
			}
		}

		[IteratorStateMachine(typeof(<ClearCursorInfoLabel>d__9))]
		public static IEnumerator ClearCursorInfoLabel()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ClearCursorInfoLabel>d__9(0);
		}
	}
	public class DragObject : ToolObject
	{
		public static readonly DragObject Instance = new DragObject();

		public override bool Highlight => true;

		public DragObject()
			: base("drag", Settings.Drag, -4)
		{
		}

		public override string GetName()
		{
			return "Drag Tool";
		}

		public override string GetDescription()
		{
			return "Click and drag a placed object to move it.\n\nHold Left Control to select multiple, or drag a box over an area.\n\nPress C to copy and V to paste the current selection.";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (first)
			{
				ObjectPlacement objectPlacement = PlacementManager.FindObject(mousePosition);
				bool isPressed = Settings.MultiSelect.IsPressed;
				if (objectPlacement != null && (!EditManager.SelectedObjects.Contains(objectPlacement) || isPressed))
				{
					EditManager.ToggleSelectedObject(objectPlacement, !isPressed);
				}
				else if (EditManager.SelectedObjects.Count == 0)
				{
					EditManager.StartGroupSelect();
				}
				else
				{
					EditManager.BeginDragging();
				}
			}
		}
	}
	public class EraserObject : ToolObject
	{
		public static readonly EraserObject Instance = new EraserObject();

		private List<ObjectPlacement> _erasedPlacements = new List<ObjectPlacement>();

		public override bool Highlight => true;

		public EraserObject()
			: base("eraser", Settings.Eraser, -2)
		{
		}

		public override string GetName()
		{
			return "Eraser";
		}

		public override string GetDescription()
		{
			return "Click or drag over a placed object to delete it.\n\nMake a selection with the Drag tool and click\nwith the Eraser to delete the selection.\n\nHold the Left Alt key to only delete the clicked object,\nrather than all objects the cursor is dragged over.";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!first && Input.GetKey((KeyCode)308))
			{
				return;
			}
			List<ObjectPlacement> list = new List<ObjectPlacement>();
			list.AddRange(EditManager.SelectedObjects);
			EditManager.SelectedObjects.Clear();
			ObjectPlacement objectPlacement = PlacementManager.FindObject(mousePosition);
			if (objectPlacement != null && !list.Contains(objectPlacement))
			{
				list.Add(objectPlacement);
			}
			if (list.Count == 0)
			{
				return;
			}
			_erasedPlacements.AddRange(list);
			foreach (ObjectPlacement item in list)
			{
				item.Destroy();
			}
		}

		public override void Release()
		{
			ActionManager.PerformAction(new EraseObject(_erasedPlacements));
			_erasedPlacements = new List<ObjectPlacement>();
		}
	}
	public class LockObject : ToolObject
	{
		public static readonly LockObject Instance = new LockObject();

		public LockObject()
			: base("lock", Settings.Lock, -7)
		{
		}

		public override string GetName()
		{
			return "Lock Tool";
		}

		public override string GetDescription()
		{
			return "Locks an object in place so it cannot be edited or selected in any way until unlocked.\nLeft Shift will only lock, Left Alt will only unlock.\n\nThis has no effect on actual gameplay, only edit mode.\n\nUseful for things like large trigger zones that may get in the way of editing.";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (first)
			{
				int includeLocked = (Input.GetKey((KeyCode)308) ? 2 : ((!Input.GetKey((KeyCode)304)) ? 1 : 0));
				ObjectPlacement objectPlacement = PlacementManager.FindObject(mousePosition, includeLocked);
				if (objectPlacement != null)
				{
					ActionManager.PerformAction(new ToggleLock(objectPlacement));
				}
			}
		}
	}
	public class PickObject : ToolObject
	{
		public static readonly PickObject Instance = new PickObject();

		public override bool Highlight => true;

		public PickObject()
			: base("pick", Settings.Pick, -3)
		{
		}

		public override string GetName()
		{
			return "Pick Tool";
		}

		public override string GetDescription()
		{
			return "Click a placed object to copy it to the cursor.\n\nTo edit a placed object without changing its ID or position select it with the Pick tool,\nmake changes and then hold 'O' and click the object to overwrite it.";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!first)
			{
				return;
			}
			ObjectPlacement objectPlacement = PlacementManager.FindObject(mousePosition);
			if (objectPlacement != null)
			{
				EditManager.TryFindEmptySlot();
				EditManager.ClearAttributes();
				EditManager.Broadcasters.AddRange(objectPlacement.Broadcasters);
				EditManager.Receivers.AddRange(objectPlacement.Receivers);
				Architect.Config.Types.ConfigValue[] config = objectPlacement.Config;
				foreach (Architect.Config.Types.ConfigValue configValue in config)
				{
					EditManager.Config[configValue.GetTypeId()] = configValue;
				}
				EditManager.SetRotation(objectPlacement.GetRotation());
				EditManager.SetScale(objectPlacement.GetScale());
				EditManager.CurrentlyFlipped = objectPlacement.IsFlipped();
				EditManager.CurrentObject = objectPlacement.GetPlacementType();
				EditorUI.RefreshAttributeControls(useDefaultConfig: false);
				EditorUI.RefreshItem();
			}
		}
	}
	public class ResetObject : ToolObject
	{
		internal static readonly ResetObject Instance = new ResetObject();

		private static float _resetTime;

		private static bool _resetting;

		public ResetObject()
			: base("reset_rocket", Settings.Reset, -5)
		{
		}

		public static void RestartDelay()
		{
			if (_resetting)
			{
				((Behaviour)EditorUI.ResetRocketTime).enabled = false;
				_resetting = false;
				_resetTime = 0f;
				EditorUI.ResetRocketTime.text = "";
			}
		}

		public override string GetName()
		{
			return "Reset";
		}

		public override string GetDescription()
		{
			return "Hold for 3 seconds to reset the current room.\n\nWarning: This cannot be undone!";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			if (first)
			{
				_resetting = true;
			}
			if (_resetting)
			{
				_resetTime += Time.deltaTime;
				if (_resetTime >= 3f)
				{
					RestartDelay();
					ActionManager.PerformAction(new ResetRoom());
				}
				else
				{
					((Behaviour)EditorUI.ResetRocketTime).enabled = true;
					EditorUI.ResetRocketTime.text = Mathf.Ceil(3f - _resetTime).ToString(CultureInfo.InvariantCulture);
				}
			}
		}
	}
	public class TileChangerObject : ToolObject
	{
		public static readonly TileChangerObject Instance = new TileChangerObject();

		private static readonly List<(int, int)> TileFlips = new List<(int, int)>();

		private static (int, int) _lastPos = (-1, -1);

		private static bool _lastEmpty;

		public TileChangerObject()
			: base("tile_changer", Settings.TileChanger, -6)
		{
		}

		public override string GetName()
		{
			return "Tilemap Editor";
		}

		public override string GetDescription()
		{
			return "Click on the tilemap to add or remove a tile.\n\nDoes not work out of bounds as the tilemap is limited to the room.";
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			tk2dTileMap tilemap = PlacementManager.GetTilemap();
			int num = default(int);
			int num2 = default(int);
			if (!Object.op_Implicit((Object)(object)tilemap) || !tilemap.GetTileAtPosition(EditManager.GetWorldPos(mousePosition), ref num, ref num2))
			{
				return;
			}
			(int, int) tuple = (num, num2);
			(int, int) lastPos = _lastPos;
			(int, int) tuple2 = tuple;
			if (lastPos.Item1 == tuple2.Item1 && lastPos.Item2 == tuple2.Item2 && !first)
			{
				return;
			}
			_lastPos = tuple;
			bool flag = tilemap.GetTile(num, num2, 0) == -1;
			if (first)
			{
				_lastEmpty = flag;
			}
			else if (_lastEmpty != flag)
			{
				return;
			}
			try
			{
				if (flag)
				{
					tilemap.SetTile(num, num2, 0, 0);
				}
				else
				{
					tilemap.ClearTile(num, num2, 0);
				}
				tilemap.Build();
			}
			catch (Exception)
			{
				return;
			}
			TileFlips.Add(tuple);
		}

		public override void Release()
		{
			ActionManager.PerformAction(new ToggleTile(TileFlips.ToList(), !_lastEmpty));
			TileFlips.Clear();
		}
	}
	public abstract class ToolObject : SelectableObject
	{
		public static readonly Dictionary<Settings.Keybind, int> Keybinds = new Dictionary<Settings.Keybind, int>();

		public readonly int Index;

		private readonly Sprite _sprite;

		public virtual bool Highlight => false;

		protected ToolObject(string path, Settings.Keybind keybind, int index)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			_sprite = ResourceUtils.LoadSpriteResource(path, (FilterMode)1);
			if (keybind != null)
			{
				Keybinds[keybind] = index;
			}
			Index = index;
			DisableTransformations = true;
		}

		public override Sprite GetUISprite()
		{
			return _sprite;
		}
	}
}
namespace Architect.Objects.Placeable
{
	public sealed class CustomObject : PlaceableObject
	{
		public CustomObject(string name, string id, GameObject prefab, string description = null, Action<GameObject> postSpawnAction = null, bool preview = false, Sprite sprite = null, Sprite uiSprite = null)
			: base(name, id, description, postSpawnAction, preview, sprite, uiSprite)
		{
			FinishSetup(prefab);
		}
	}
	public abstract class PlaceableObject : SelectableObject
	{
		public class SpriteSource : MonoBehaviour
		{
		}

		public static readonly Dictionary<string, PlaceableObject> RegisteredObjects = new Dictionary<string, PlaceableObject>();

		public readonly bool Preview;

		public Action<GameObject> PostSpawnAction;

		public GameObject Prefab;

		public Sprite Sprite;

		private readonly Sprite _uiSprite;

		public Vector3 Offset;

		public Vector3 ChildOffset;

		public Vector3 ParentScale;

		public Vector3 LossyScale;

		public float Rotation;

		public float ChildRotation;

		public int Tk2dRotation;

		public float ZPosition;

		public bool FlipX;

		public bool IgnoreScale;

		private readonly string _name;

		private readonly string _description;

		private readonly string _id;

		[CanBeNull]
		public Action<GameObject, bool> FlipAction;

		[CanBeNull]
		public Action<GameObject, float> RotateAction;

		[CanBeNull]
		public Action<GameObject, float> ScaleAction;

		private RotationGroup _rotationGroup = RotationGroup.None;

		public List<EventReceiverType> ReceiverGroup = Architect.Objects.Groups.ReceiverGroup.Generic;

		public List<OutputType> OutputGroup = Architect.Objects.Groups.OutputGroup.Objects;

		public List<(string, string)> InputGroup = Architect.Objects.Groups.InputGroup.Generic;

		public List<Architect.Config.Types.ConfigType> ConfigGroup = Architect.Objects.Groups.ConfigGroup.Visible;

		public List<string> BroadcasterGroup = new List<string>();

		protected PlaceableObject(string name, string id, string description = null, Action<GameObject> postSpawnAction = null, bool preview = false, Sprite sprite = null, Sprite uiSprite = null)
		{
			_name = name;
			_id = id;
			_description = description;
			PostSpawnAction = postSpawnAction;
			Preview = preview;
			Sprite = sprite;
			_uiSprite = uiSprite;
			RegisteredObjects[id] = this;
		}

		public override Sprite GetUISprite()
		{
			return Object.op_Implicit((Object)(object)_uiSprite) ? _uiSprite : Sprite;
		}

		protected void FinishSetup(GameObject prefab)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			Prefab = prefab;
			SetZ component = Prefab.GetComponent<SetZ>();
			if (Object.op_Implicit((Object)(object)component))
			{
				Vector3 position = Prefab.transform.position;
				position.z = component.z;
				Prefab.transform.position = position;
			}
			ZPosition = Prefab.transform.position.z;
			Prefab.RemoveComponent<BlackThreadState>();
			ParentScale = Prefab.transform.lossyScale;
			if (Object.op_Implicit((Object)(object)Sprite))
			{
				LossyScale = ParentScale;
			}
			else
			{
				Sprite = RetrieveSprite();
			}
			if (IgnoreScale)
			{
				ParentScale = Vector3.one;
				LossyScale = Vector3.one;
			}
			if (!Object.op_Implicit((Object)(object)Sprite))
			{
				ArchitectPlugin.Logger.LogError((object)("No sprite found for " + _name));
			}
		}

		public PlaceableObject WithRotationGroup(RotationGroup group)
		{
			_rotationGroup = group;
			return this;
		}

		public PlaceableObject WithReceiverGroup(List<EventReceiverType> group)
		{
			ReceiverGroup = group;
			return this;
		}

		public PlaceableObject WithOutputGroup(List<OutputType> group)
		{
			OutputGroup = group;
			return this;
		}

		public PlaceableObject WithInputGroup(List<(string, string)> group)
		{
			InputGroup = group;
			return this;
		}

		public PlaceableObject WithConfigGroup(List<Architect.Config.Types.ConfigType> group)
		{
			ConfigGroup = group;
			return this;
		}

		public PlaceableObject WithBroadcasterGroup(List<string> group)
		{
			BroadcasterGroup = group;
			return this;
		}

		public PlaceableObject DoFlipX()
		{
			FlipX = true;
			return this;
		}

		public PlaceableObject DoIgnoreScale()
		{
			IgnoreScale = true;
			return this;
		}

		public RotationGroup GetRotationGroup()
		{
			return _rotationGroup;
		}

		public override string GetName()
		{
			return _name;
		}

		public string GetId()
		{
			return _id;
		}

		public override string GetDescription()
		{
			return _description;
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (!first)
			{
				return;
			}
			if (EditManager.HoveredObject != null && Settings.GrabId.IsPressed)
			{
				if (EditorUI.ConfigIds.Count > 0)
				{
					(InputField, Action) tuple = EditorUI.ConfigIds.FirstOrDefault(((InputField, Action) o) => Utility.IsNullOrWhiteSpace(o.Item1.text));
					var (val, action) = tuple;
					if ((Object)(object)val == (Object)null && (Delegate?)action == (Delegate?)null)
					{
						tuple = EditorUI.ConfigIds[0];
					}
					tuple.Item1.text = EditManager.HoveredObject.GetId();
					tuple.Item2();
				}
				return;
			}
			Vector3 worldPos = EditManager.GetWorldPos(mousePosition, lockAxisApplies: true);
			worldPos.z = ZPosition;
			ObjectPlacement objectPlacement = PreparePlacement(worldPos);
			if (Settings.StartLocked.IsPressed)
			{
				objectPlacement.ToggleLocked();
			}
			EditManager.RegisterLastPos(Vector2.op_Implicit(worldPos));
			ActionManager.PerformAction(new PlaceObjects(new List<ObjectPlacement>(1) { objectPlacement }));
			if (Settings.StartScripted.IsPressed)
			{
				ScriptManager.AddToScript(objectPlacement);
			}
		}

		public ObjectPlacement PreparePlacement(Vector3 pos)
		{
			//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_005d: Unknown result type (might be due to invalid IL or missing references)
			ObjectPlacement hoveredObject = EditManager.HoveredObject;
			string id;
			if (hoveredObject != null)
			{
				pos = hoveredObject.GetPos();
				id = hoveredObject.GetId();
				ActionManager.PerformAction(new EraseObject(new List<ObjectPlacement>(1) { hoveredObject }));
				EditManager.HoveredObject = null;
			}
			else
			{
				id = Guid.NewGuid().ToString().Substring(0, 8);
			}
			return new ObjectPlacement(this, pos, id, EditManager.CurrentlyFlipped, EditManager.CurrentRotation, EditManager.CurrentScale, locked: false, EditManager.Layer, EditManager.Broadcasters.ToArray(), EditManager.Receivers.ToArray(), EditManager.Config.Values.ToArray());
		}

		private Sprite RetrieveSprite()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			SpriteSource componentInChildren = Prefab.GetComponentInChildren<SpriteSource>(true);
			if (!Object.op_Implicit((Object)(object)componentInChildren))
			{
				SpriteRenderer component = Prefab.GetComponent<SpriteRenderer>();
				Quaternion rotation;
				if (Object.op_Implicit((Object)(object)component))
				{
					rotation = Prefab.transform.rotation;
					Rotation = ((Quaternion)(ref rotation)).eulerAngles.z;
					LossyScale = ParentScale;
					return component.sprite;
				}
				tk2dSprite component2 = Prefab.GetComponent<tk2dSprite>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					rotation = Prefab.transform.rotation;
					Rotation = ((Quaternion)(ref rotation)).eulerAngles.z;
					LossyScale = ParentScale;
					return PrepareSpriteWithTk2D(component2, child: false);
				}
			}
			GameObject val = ((componentInChildren != null) ? ((Component)componentInChildren).gameObject : null) ?? Prefab;
			tk2dSprite componentInChildren2 = val.GetComponentInChildren<tk2dSprite>();
			if (Object.op_Implicit((Object)(object)componentInChildren2) && (!Object.op_Implicit((Object)(object)componentInChildren) || !((Object)(object)((Component)componentInChildren2).gameObject != (Object)(object)val) || !Object.op_Implicit((Object)(object)val.GetComponent<SpriteRenderer>())))
			{
				ChildOffset = ((Component)componentInChildren2).gameObject.transform.position - Prefab.transform.position;
				ChildRotation = ((Component)componentInChildren2).gameObject.transform.eulerAngles.z;
				LossyScale = ((Component)componentInChildren2).gameObject.transform.lossyScale;
				return PrepareSpriteWithTk2D(componentInChildren2, child: true);
			}
			SpriteRenderer componentInChildren3 = val.GetComponentInChildren<SpriteRenderer>();
			if (!Object.op_Implicit((Object)(object)componentInChildren3))
			{
				return null;
			}
			ChildOffset = ((Component)componentInChildren3).gameObject.transform.position - Prefab.transform.position;
			ChildRotation = ((Component)componentInChildren3).gameObject.transform.eulerAngles.z;
			LossyScale = ((Component)componentInChildren3).gameObject.transform.lossyScale;
			return componentInChildren3.sprite;
		}

		private Sprite PrepareSpriteWithTk2D(tk2dSprite sprite, bool child)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			tk2dSpriteAnimator component = ((Component)sprite).gameObject.GetComponent<tk2dSpriteAnimator>();
			tk2dSpriteDefinition val = ((tk2dBaseSprite)sprite).CurrentSprite;
			if (Object.op_Implicit((Object)(object)component))
			{
				tk2dSpriteAnimationClip defaultClip = component.DefaultClip;
				if (defaultClip != null)
				{
					tk2dSpriteAnimationFrame val2 = defaultClip.frames[0];
					val = val2.spriteCollection.spriteDefinitions[val2.spriteId];
				}
			}
			if ((int)val.flipped > 0)
			{
				Tk2dRotation += 90;
			}
			Bounds bounds = val.GetBounds();
			Vector3 center = ((Bounds)(ref bounds)).center;
			if (child)
			{
				ChildOffset += center;
			}
			else
			{
				Offset += center;
			}
			return PreviewUtils.ConvertFrom2DToolkit(val, Mathf.Abs(1f / (((tk2dBaseSprite)sprite).scale.x * ((tk2dBaseSprite)sprite).GetCurrentSpriteDef().texelSize.x)));
		}

		public PlaceableObject WithFlipAction(Action<GameObject, bool> flipAction)
		{
			FlipAction = flipAction;
			return this;
		}

		public PlaceableObject WithRotateAction(Action<GameObject, float> rotateAction)
		{
			RotateAction = rotateAction;
			return this;
		}

		public PlaceableObject WithScaleAction(Action<GameObject, float> scaleAction)
		{
			ScaleAction = scaleAction;
			return this;
		}
	}
	public class PreloadObject : PlaceableObject, IPreload
	{
		[CompilerGenerated]
		private sealed class <EnsureLoaded>d__21 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PreloadObject <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this.Loaded)
					{
						return false;
					}
					PreloadManager.IsLoading = true;
					<>2__current = <>4__this._asset.Load();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (<>4__this._asset.Handle.OperationException != null || <>4__this.Loaded)
					{
						PreloadManager.IsLoading = false;
						return false;
					}
					<>4__this.Loaded = true;
					<>4__this.OnPreload(<>4__this._asset.Handle.Result);
					PreloadManager.IsLoading = false;
					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 ShouldLoad;

		private readonly Action<GameObject> _preloadAction;

		private ManagedAsset<GameObject> _asset;

		public bool Loaded { get; private set; }

		public string Scene { get; }

		public string Path { get; }

		public bool IsNotSceneBundle { get; }

		public bool ShouldAlwaysLoad => ShouldLoad || Settings.LoadAllAssets.Value;

		public void MarkLoaded()
		{
		}

		public PreloadObject(string name, string id, (string, string) path, string description = null, Action<GameObject> postSpawnAction = null, Action<GameObject> preloadAction = null, bool preview = false, bool notSceneBundle = false, Sprite sprite = null, Sprite uiSprite = null)
			: base(name, id, description, postSpawnAction, preview, sprite, uiSprite)
		{
			Scene = path.Item1;
			Path = path.Item2;
			IsNotSceneBundle = notSceneBundle;
			_preloadAction = preloadAction;
			PreloadManager.RegisterPreload(this);
		}

		public void SetAsset(ManagedAsset<GameObject> asset)
		{
			_asset = asset;
		}

		[IteratorStateMachine(typeof(<EnsureLoaded>d__21))]
		public override IEnumerator EnsureLoaded()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnsureLoaded>d__21(0)
			{
				<>4__this = this
			};
		}

		public void OnPreload(GameObject preload)
		{
			if (IsNotSceneBundle && Object.op_Implicit((Object)(object)preload.GetComponent<HealthManager>()))
			{
				bool activeSelf = preload.activeSelf;
				preload.SetActive(false);
				GameObject val = preload;
				preload = Object.Instantiate<GameObject>(preload);
				Object.DontDestroyOnLoad((Object)(object)preload);
				if (activeSelf)
				{
					val.SetActive(true);
				}
			}
			_preloadAction?.Invoke(preload);
			FinishSetup(preload);
			Loaded = true;
		}
	}
	public class SavedObject : SelectableObject
	{
		private Sprite _extraSprite;

		public readonly ObjectPlacement Placement;

		public readonly PlaceableObject PlaceableObject;

		public SavedObject(ObjectPlacement placement)
		{
			Placement = placement;
			PlaceableObject = placement.GetPlacementType();
			Architect.Config.Types.ConfigValue configValue = placement.Config.FirstOrDefault((Architect.Config.Types.ConfigValue c) => c.GetTypeId() == "png_url");
			if (configValue != null)
			{
				string url = configValue.SerializeValue();
				CustomAssetManager.DoLoadSprite(url, point: true, 100f, 1, 1, delegate(Sprite[] sprites)
				{
					_extraSprite = sprites[0];
				});
			}
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(PlaceableObject.EnsureLoaded());
		}

		public override string GetName()
		{
			return "Prefab Object";
		}

		public override string GetDescription()
		{
			return null;
		}

		public override void Click(Vector3 mousePosition, bool first)
		{
		}

		public override Sprite GetUISprite()
		{
			return _extraSprite ?? PlaceableObject.Sprite;
		}
	}
}
namespace Architect.Objects.Groups
{
	public static class BroadcasterGroup
	{
		public static readonly List<string> TriggerZone = new List<string>(2) { "ZoneEnter", "ZoneExit" };

		public static readonly List<string> Damageable = new List<string>(1) { "OnDamage" };

		public static readonly List<string> BindSourceStab = new List<string>(2) { "OnBind", "OnFinalBind" };

		public static readonly List<string> BindSourceStand = new List<string>(2) { "OnFinishTalk", "OnFinalBind" };

		public static readonly List<string> Exploding = new List<string>(1) { "OnExplode" };

		public static readonly List<string> TempGate = new List<string>(2) { "OnOpen", "OnClose" };

		public static readonly List<string> Ventrica = new List<string>(1) { "OnEnter" };

		public static readonly List<string> Enemies = new List<string>(4) { "OnDeath", "FirstDeath", "LoadedDead", "OnDamage" };

		public static readonly List<string> Shardillard = GroupUtils.Merge(Enemies, new List<string>(1) { "OnBounce" });

		public static readonly List<string> Judge = GroupUtils.Merge(Enemies, new List<string>(1) { "OnBlock" });

		public static readonly List<string> Ambushers = GroupUtils.Merge(Enemies, new List<string>(1) { "OnAmbush" });

		public static readonly List<string> Transitions = new List<string>(1) { "OnExit" };

		public static readonly List<string> Npcs = new List<string>(1) { "OnFinish" };

		public static readonly List<string> EnemyDamager = new List<string>(1) { "OnDamage" };

		public static readonly List<string> FsmHook = new List<string>(2) { "OnChange", "OnTarget" };

		public static readonly List<string> Snitchfly = GroupUtils.Merge(Enemies, new List<string>(1) { "OnFlee" });

		public static readonly List<string> Bosses = new List<string>(5) { "OnRoar", "OnDeath", "FirstDeath", "LoadedDead", "OnDamage" };

		public static readonly List<string> SkullTyrant = GroupUtils.Merge(Bosses, new List<string>(1) { "Stomp" });

		public static readonly List<string> LastJudge = GroupUtils.Merge(Bosses, new List<string>(6) { "Swing", "Slam", "FireSlam", "CenserThrow", "CenserSlam", "FlameCharge" });

		public static readonly List<string> Karmelita = GroupUtils.Merge(Bosses, new List<string>(2) { "OnStun", "OnRecover" });

		public static readonly List<string> Lugoli = GroupUtils.Merge(Bosses, new List<string>(3) { "OnStompLand", "OnButtLand", "OnLadleSlam" });

		public static readonly List<string> SisterSplinter = GroupUtils.Merge(Bosses, new List<string>(2) { "TrySpikes", "TrySummon" });

		public static readonly List<string> BlackThreader = new List<string>(1) { "OnAttack" };

		public static readonly List<string> SlamEnemies = GroupUtils.Merge(Enemies, new List<string>(1) { "Slam" });

		public static readonly List<string> SlamBosses = GroupUtils.Merge(Bosses, new List<string>(1) { "Slam" });

		public static readonly List<string> SummonerBosses = GroupUtils.Merge(Bosses, new List<string>(1) { "TrySummon" });

		public static readonly List<string> SavageBeastfly = GroupUtils.Merge(SummonerBosses, new List<string>(2) { "WallSlam", "FloorSlam" });

		public static readonly List<string> Groal = GroupUtils.Merge(SummonerBosses, new List<string>(1) { "TrySpikeTrap" });

		public static readonly List<string> Activatable = new List<string>(1) { "OnActivate" };

		public static readonly List<string> Finishable = new List<string>(1) { "OnFinish" };

		public static readonly List<string> Png = new List<string>(2) { "OnFinish", "OnFrameChange" };

		public static readonly List<string> Toll = new List<string>(1) { "OnPay" };

		public static readonly List<string> Breakable = new List<string>(1) { "OnBreak" };

		public static readonly List<string> PersistentBreakable = new List<string>(3) { "OnBreak", "FirstBreak", "LoadedBroken" };

		public static readonly List<string> SilkVines = GroupUtils.Merge(PersistentBreakable, new List<string>(2) { "OnHit", "OnTempBreak" });

		public static readonly List<string> ActiveDeactivatable = new List<string>(2) { "OnActivate", "OnDeactivate" };

		public static readonly List<string> Levers = new List<string>(3) { "OnPull", "FirstPull", "LoadedPulled" };

		public static readonly List<string> Buttons = new List<string>(3) { "OnPress", "FirstPress", "LoadedPressed" };

		public static readonly List<string> Bindings = new List<string>(2) { "OnBind", "OnUnbind" };

		public static readonly List<string> Binoculars = new List<string>(2) { "OnStart", "OnStop" };

		public static readonly List<string> Callable = new List<string>(1) { "OnCall" };

		public static readonly List<string> Benches = new List<string>(3) { "OnSit", "OnLeave", "OnSpawnAt" };

		public static readonly List<string> Item = new List<string>(1) { "BeforePickup" };

		public static readonly List<string> MapperRing = new List<string>(4) { "InAir", "OnHit", "OnLand", "OnCollide" };

		public static readonly List<string> Hittable = new List<string>(1) { "OnHit" };

		public static readonly List<string> KeyListener = new List<string>(2) { "KeyPressed", "KeyReleased" };

		public static readonly List<string> AbilityCrystal = new List<string>(2) { "OnCollect", "OnRegen" };

		public static readonly List<string> HarpoonRings = new List<string>(2) { "OnGrab", "OnRelease" };

		public static readonly List<string> Choice = new List<string>(2) { "Yes", "No" };

		public static readonly List<string> ObjectAnchor = new List<string>(2) { "OnReverse", "OnTrackEnd" };

		public static readonly List<string> TextDisplay = new List<string>(1) { "OnClose" };

		public static readonly List<string> Interaction = new List<string>(1) { "OnInteract" };

		public static readonly List<string> Fleas = new List<string>(1) { "OnSave" };

		public static readonly List<string> FleaCounter = new List<string>(4) { "OnGold", "OnSilver", "OnBronze", "OnWhite" };

		public static readonly List<string> Killable = new List<string>(1) { "OnDeath" };

		public static readonly List<string> PlayerHooks = new List<string>(15)
		{
			"FaceLeft", "FaceRight", "Jump", "WallJump", "DoubleJump", "Land", "HardLand", "Dash", "Attack", "OnHazardRespawn",
			"OnDamage", "OnDeath", "OnHeal", "NeedolinStart", "NeedolinStop"
		};
	}
	public static class ConfigGroup
	{
		public class GravityLock : MonoBehaviour
		{
			public float level;

			public Rigidbody2D rb2d;

			private void Start()
			{
				rb2d = ((Component)this).gameObject.GetComponentInChildren<Rigidbody2D>(true);
				if (!Object.op_Implicit((Object)(object)rb2d))
				{
					rb2d = ((Component)this).gameObject.AddComponent<Rigidbody2D>();
				}
			}

			private void Update()
			{
				rb2d.gravityScale = level;
				rb2d.collisionDetectionMode = (CollisionDetectionMode2D)1;
			}
		}

		public class EnemyInvulnerabilityMarker : MonoBehaviour
		{
		}

		public class JournalKillDisablerMarker : MonoBehaviour
		{
		}

		public class DeleteAfterTime : MonoBehaviour
		{
			public float value;

			private void Update()
			{
				value -= Time.deltaTime;
				if (value <= 0f)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
			}
		}

		public static readonly List<Architect.Config.Types.ConfigType> Generic;

		public static readonly List<Architect.Config.Types.ConfigType> Disabler;

		public static readonly List<Architect.Config.Types.ConfigType> Prefab;

		public static readonly List<Architect.Config.Types.ConfigType> ObjectLayerer;

		public static readonly List<Architect.Config.Types.ConfigType> EnviroRegion;

		private static readonly Architect.Config.Types.ConfigType Hook;

		public static readonly List<Architect.Config.Types.ConfigType> ObjectHook;

		public static readonly List<Architect.Config.Types.ConfigType> EnemyHook;

		public static readonly List<Architect.Config.Types.ConfigType> CocoonSpawnPoint;

		public static readonly List<Architect.Config.Types.ConfigType> Darkness;

		public static readonly List<Architect.Config.Types.ConfigType> Dust;

		public static readonly List<Architect.Config.Types.ConfigType> AudioPlayer;

		public static readonly List<Architect.Config.Types.ConfigType> Visible;

		public static readonly List<Architect.Config.Types.ConfigType> VoidTsunami;

		public static readonly List<Architect.Config.Types.ConfigType> Treadmill;

		public static readonly List<Architect.Config.Types.ConfigType> DocksLift;

		public static readonly List<Architect.Config.Types.ConfigType> Ventrica;

		public static readonly List<Architect.Config.Types.ConfigType> Cocoon;

		public static readonly List<Architect.Config.Types.ConfigType> Teleporter;

		public static readonly List<Architect.Config.Types.ConfigType> VerticalRing;

		public static readonly List<Architect.Config.Types.ConfigType> Chest;

		public static readonly List<Architect.Config.Types.ConfigType> Item;

		public static readonly List<Architect.Config.Types.ConfigType> CoralNut;

		public static readonly List<Architect.Config.Types.ConfigType> LoreTablets;

		public static readonly List<Architect.Config.Types.ConfigType> DoubleLoreTablet;

		public static readonly List<Architect.Config.Types.ConfigType> Bell;

		public static readonly List<Architect.Config.Types.ConfigType> JellyEgg;

		public static readonly List<Architect.Config.Types.ConfigType> NeedolinGate;

		public static readonly List<Architect.Config.Types.ConfigType> JunkPipe;

		public static readonly List<Architect.Config.Types.ConfigType> BlackThreader;

		public static readonly List<Architect.Config.Types.ConfigType> Plasmifier;

		public static readonly List<Architect.Config.Types.ConfigType> Shielder;

		public static readonly List<Architect.Config.Types.ConfigType> AnimPlayer;

		public static readonly List<Architect.Config.Types.ConfigType> TimeSlower;

		public static readonly List<Architect.Config.Types.ConfigType> Toll;

		public static readonly List<Architect.Config.Types.ConfigType> MapStateHook;

		public static readonly List<Architect.Config.Types.ConfigType> CameraBorder;

		public static readonly List<Architect.Config.Types.ConfigType> Wisp;

		public static readonly List<Architect.Config.Types.ConfigType> AllyWisp;

		public static readonly List<Architect.Config.Types.ConfigType> Roar;

		public static readonly List<Architect.Config.Types.ConfigType> CloseableGates;

		public static readonly List<Architect.Config.Types.ConfigType> Relay;

		public static readonly List<Architect.Config.Types.ConfigType> Timer;

		public static readonly List<Architect.Config.Types.ConfigType> Mutable;

		public static readonly List<Architect.Config.Types.ConfigType> Coral;

		public static readonly List<Architect.Config.Types.ConfigType> AbilityCrystal;

		public static readonly List<Architect.Config.Types.ConfigType> Duplicator;

		public static readonly List<Architect.Config.Types.ConfigType> Camera;

		public static readonly List<Architect.Config.Types.ConfigType> Zaprock;

		public static readonly List<Architect.Config.Types.ConfigType> Levers;

		public static readonly List<Architect.Config.Types.ConfigType> Buttons;

		public static readonly List<Architect.Config.Types.ConfigType> Frost;

		public static readonly List<Architect.Config.Types.ConfigType> Stretchable;

		public static readonly List<Architect.Config.Types.ConfigType> PlayerBarrier;

		public static readonly List<Architect.Config.Types.ConfigType> Updraft;

		public static readonly List<Architect.Config.Types.ConfigType> Wind;

		public static readonly List<Architect.Config.Types.ConfigType> Slope;

		public static readonly List<Architect.Config.Types.ConfigType> Water;

		public static readonly List<Architect.Config.Types.ConfigType> DreamBlock;

		public static readonly List<Architect.Config.Types.ConfigType> CradlePlat;

		private static readonly string[] CrumbleHazardStates;

		public static readonly List<Architect.Config.Types.ConfigType> CrumblePlat;

		public static readonly List<Architect.Config.Types.ConfigType> SilkSpool;

		public static readonly List<Architect.Config.Types.ConfigType> SilkHeart;

		public static readonly List<Architect.Config.Types.ConfigType> MaskAndSpool;

		public static readonly List<Architect.Config.Types.ConfigType> SilkLever;

		private static readonly Architect.Config.Types.ConfigType RenderLayer;

		public static readonly Architect.Config.Types.ConfigType ZOffset;

		public static readonly List<Architect.Config.Types.ConfigType> Sandcarver;

		public static readonly List<Architect.Config.Types.ConfigType> CameraView;

		public static readonly List<Architect.Config.Types.ConfigType> Dialogue;

		public static readonly List<Architect.Config.Types.ConfigType> Npcs;

		public static readonly List<Architect.Config.Types.ConfigType> Pavo;

		public static readonly List<Architect.Config.Types.ConfigType> SeerZi;

		public static readonly List<Architect.Config.Types.ConfigType> MaskMaker;

		public static readonly List<Architect.Config.Types.ConfigType> Shakra;

		public static readonly List<Architect.Config.Types.ConfigType> Sherma;

		public static readonly List<Architect.Config.Types.ConfigType> Caretaker;

		public static readonly List<Architect.Config.Types.ConfigType> Silkfly;

		public static readonly List<Architect.Config.Types.ConfigType> Fayforn;

		public static readonly List<Architect.Config.Types.ConfigType> BlurPlane;

		private static readonly int HeatSpeed;

		public static readonly List<Architect.Config.Types.ConfigType> HeatPlane;

		public static readonly List<Architect.Config.Types.ConfigType> Decorations;

		public static readonly List<Architect.Config.Types.ConfigType> StretchDecor;

		public static readonly List<Architect.Config.Types.ConfigType> StretchColourDecor;

		public static readonly List<Architect.Config.Types.ConfigType> Vines;

		public static readonly List<Architect.Config.Types.ConfigType> PersistentBreakable;

		public static readonly List<Architect.Config.Types.ConfigType> Statue;

		public static readonly List<Architect.Config.Types.ConfigType> BodySack;

		private static readonly Architect.Config.Types.ConfigType IsBreakable;

		public static readonly List<Architect.Config.Types.ConfigType> BreakableDecor;

		public static readonly List<Architect.Config.Types.ConfigType> WispLanterns;

		public static readonly List<Architect.Config.Types.ConfigType> BreakableWall;

		public static readonly List<Architect.Config.Types.ConfigType> ExplodingWall;

		public static readonly List<Architect.Config.Types.ConfigType> LifebloodCocoons;

		public static readonly List<Architect.Config.Types.ConfigType> TrackPoint;

		public static readonly List<Architect.Config.Types.ConfigType> TrackStartPoint;

		private static readonly int Terrain;

		private static readonly int Default;

		public static readonly List<Architect.Config.Types.ConfigType> Colliders;

		public static readonly List<Architect.Config.Types.ConfigType> BellPlat3;

		private static readonly Architect.Config.Types.ConfigType AlphaColour;

		public static readonly List<Architect.Config.Types.ConfigType> Colours;

		public static readonly List<Architect.Config.Types.ConfigType> Line;

		public static readonly List<Architect.Config.Types.ConfigType> Colourer;

		public static readonly List<Architect.Config.Types.ConfigType> Gravity;

		public static readonly List<Architect.Config.Types.ConfigType> TriggerActivator;

		public static readonly List<Architect.Config.Types.ConfigType> Kratt;

		public static readonly List<Architect.Config.Types.ConfigType> CoralSpike;

		public static readonly List<Architect.Config.Types.ConfigType> FakePerformance;

		public static readonly List<Architect.Config.Types.ConfigType> PlayerDataSetter;

		public static readonly List<Architect.Config.Types.ConfigType> Fleas;

		public static readonly List<Architect.Config.Types.ConfigType> Benches;

		public static readonly List<Architect.Config.Types.ConfigType> FullBellBench;

		public static readonly List<Architect.Config.Types.ConfigType> WalkTarget;

		public static readonly List<Architect.Config.Types.ConfigType> BellBench;

		public static readonly List<Architect.Config.Types.ConfigType> ObjectSpinner;

		public static readonly List<Architect.Config.Types.ConfigType> FsmHook;

		public static readonly List<Architect.Config.Types.ConfigType> ComponentHook;

		public static readonly List<Architect.Config.Types.ConfigType> ObjectAnchor;

		public static readonly List<Architect.Config.Types.ConfigType> ObjectMover;

		private static readonly Architect.Config.Types.ConfigType Invincible;

		public static readonly List<Architect.Config.Types.ConfigType> SimpleEnemies;

		public static readonly List<Architect.Config.Types.ConfigType> Garpid;

		public static readonly List<Architect.Config.Types.ConfigType> NonPersistentEnemies;

		public static readonly List<Architect.Config.Types.ConfigType> Enemies;

		public static readonly List<Architect.Config.Types.ConfigType> Lilypad;

		public static readonly List<Architect.Config.Types.ConfigType> Squirm;

		public static readonly List<Architect.Config.Types.ConfigType> Hornfly;

		public static readonly List<Architect.Config.Types.ConfigType> Aknids;

		public static readonly List<Architect.Config.Types.ConfigType> Karaka;

		public static readonly List<Architect.Config.Types.ConfigType> Aknid;

		public static readonly List<Architect.Config.Types.ConfigType> AknidMother;

		public static readonly List<Architect.Config.Types.ConfigType> Furm;

		public static readonly List<Architect.Config.Types.ConfigType> WingedFurm;

		public static readonly List<Architect.Config.Types.ConfigType> YPatroller;

		public static readonly List<Architect.Config.Types.ConfigType> Patroller;

		public static readonly List<Architect.Config.Types.ConfigType> HugeFlea;

		public static readonly List<Architect.Config.Types.ConfigType> Gromling;

		public static readonly List<Architect.Config.Types.ConfigType> Grom;

		public static readonly List<Architect.Config.Types.ConfigType> Slowdown;

		public static readonly List<Architect.Config.Types.ConfigType> Bosses;

		public static readonly List<Architect.Config.Types.ConfigType> FourthChorus;

		private static readonly Architect.Config.Types.ConfigType DamagesEnemies;

		public static readonly List<Architect.Config.Types.ConfigType> Damager;

		public static readonly List<Architect.Config.Types.ConfigType> GarmondBoss;

		public static readonly List<Architect.Config.Types.ConfigType> ShakraBoss;

		public static readonly List<Architect.Config.Types.ConfigType> LeafRoller;

		public static readonly List<Architect.Config.Types.ConfigType> CameraShaker;

		public static readonly List<Architect.Config.Types.ConfigType> SavageBeastfly;

		public static readonly List<Architect.Config.Types.ConfigType> MossMother;

		public static readonly List<Architect.Config.Types.ConfigType> LastJudge;

		public static readonly List<Architect.Config.Types.ConfigType> LastClaw;

		public static readonly List<Architect.Config.Types.ConfigType> Wakeable;

		public static readonly List<Architect.Config.Types.ConfigType> WakeableBosses;

		public static readonly List<Architect.Config.Types.ConfigType> Moorwing;

		public static readonly List<Architect.Config.Types.ConfigType> Boran;

		public static readonly List<Architect.Config.Types.ConfigType> Velocity;

		public static readonly List<Architect.Config.Types.ConfigType> VelocityDamager;

		public static readonly List<Architect.Config.Types.ConfigType> Bubble;

		public static readonly List<Architect.Config.Types.ConfigType> Watcher;

		public static readonly List<Architect.Config.Types.ConfigType> BurningBug;

		public static readonly List<Architect.Config.Types.ConfigType> HideBody;

		public static readonly List<Architect.Config.Types.ConfigType> Surgeon;

		public static readonly List<Architect.Config.Types.ConfigType> Clawmaiden;

		public static readonly List<Architect.Config.Types.ConfigType> Jailer;

		public static readonly List<Architect.Config.Types.ConfigType> Hoker;

		public static readonly List<Architect.Config.Types.ConfigType> Metronome;

		public static readonly List<Architect.Config.Types.ConfigType> TextDisplay;

		public static readonly List<Architect.Config.Types.ConfigType> TitleDisplay;

		public static readonly List<Architect.Config.Types.ConfigType> Choice;

		public static readonly Architect.Config.Types.ConfigType PngUrl;

		public static readonly Architect.Config.Types.ConfigType Aa;

		public static readonly List<Architect.Config.Types.ConfigType> Png;

		public static readonly List<Architect.Config.Types.ConfigType> PhysicalPng;

		private static readonly int SwaySpeed;

		private static readonly int SwayAmount;

		private static readonly int SwayMultiplier;

		public static readonly List<Architect.Config.Types.ConfigType> Sway;

		public static readonly List<Architect.Config.Types.ConfigType> FullPng;

		public static readonly List<Architect.Config.Types.ConfigType> PngUI;

		private static readonly Architect.Config.Types.ConfigType WavUrl;

		public static readonly List<Architect.Config.Types.ConfigType> Wav;

		public static readonly List<Architect.Config.Types.ConfigType> Mp4;

		private static readonly int ActiveRegion;

		private static readonly int SoftTerrain;

		public static readonly List<Architect.Config.Types.ConfigType> TriggerZones;

		public static readonly List<Architect.Config.Types.ConfigType> EnemyDamager;

		public static readonly List<Architect.Config.Types.ConfigType> FleaCounter;

		public static readonly List<Architect.Config.Types.ConfigType> Interaction;

		public static readonly List<Architect.Config.Types.ConfigType> RosaryBead;

		public static readonly List<Architect.Config.Types.ConfigType> HazardRespawn;

		private static readonly int ReflectionOffset;

		public static readonly List<Architect.Config.Types.ConfigType> Mirror;

		private static readonly int Speed;

		public static readonly List<Architect.Config.Types.ConfigType> FlowingWater;

		public static readonly List<Architect.Config.Types.ConfigType> PoleRing;

		public static readonly List<Architect.Config.Types.ConfigType> MapperRing;

		public static readonly List<Architect.Config.Types.ConfigType> Transitions;

		public static readonly List<Architect.Config.Types.ConfigType> BindSource;

		public static readonly List<Architect.Config.Types.ConfigType> Skarrwing;

		public static readonly List<Architect.Config.Types.ConfigType> SpearSkarr;

		public static readonly List<Architect.Config.Types.ConfigType> Judge;

		public static readonly List<Architect.Config.Types.ConfigType> Bindings;

		public static readonly List<Architect.Config.Types.ConfigType> KeyListener;

		public static readonly List<Architect.Config.Types.ConfigType> Bumpers;

		public static readonly List<Architect.Config.Types.ConfigType> Remover;

		public static readonly List<Architect.Config.Types.ConfigType> DisableRenderer;

		public static readonly List<Architect.Config.Types.ConfigType> RoomClearer;

		public static readonly List<Architect.Config.Types.ConfigType> ObjectRemover;

		public static readonly List<Architect.Config.Types.ConfigType> ObjectEnabler;

		public static readonly List<Architect.Config.Types.ConfigType> PlayerHazards;

		public static readonly List<Architect.Config.Types.ConfigType> Hazards;

		public static readonly List<Architect.Config.Types.ConfigType> StretchableHazards;

		public static readonly List<Architect.Config.Types.ConfigType> WhiteSpikes;

		public static readonly List<Architect.Config.Types.ConfigType> Cogs;

		public static readonly List<Architect.Config.Types.ConfigType> Binoculars;

		public static readonly List<Architect.Config.Types.ConfigType> CloverPod;

		public static readonly List<Architect.Config.Types.ConfigType> BellPod;

		public static readonly List<Architect.Config.Types.ConfigType> FallingBell;

		public static readonly List<Architect.Config.Types.ConfigType> GrindPlat;

		public static readonly List<Architect.Config.Types.ConfigType> BlackStrand;

		public static readonly List<Architect.Config.Types.ConfigType> BounceFlea;

		public static readonly List<Architect.Config.Types.ConfigType> DodgeFlea;

		static ConfigGroup()
		{
			//IL_1e9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_27c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_2c94: Unknown result type (might be due to invalid IL or missing references)
			//IL_2d73: Unknown result type (might be due to invalid IL or missing references)
			//IL_310a: Unknown result type (might be due to invalid IL or missing references)
			//IL_32b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_3379: Unknown result type (might be due to invalid IL or missing references)
			//IL_3424: Unknown result type (might be due to invalid IL or missing references)
			//IL_375e: Unknown result type (might be due to invalid IL or missing references)
			//IL_3dfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_43c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_45b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_4659: Unknown result type (might be due to invalid IL or missing references)
			//IL_5854: Unknown result type (might be due to invalid IL or missing references)
			//IL_60fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_7337: Unknown result type (might be due to invalid IL or missing references)
			//IL_7366: Unknown result type (might be due to invalid IL or missing references)
			Generic = new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Active", "start_active", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.SetActive(false);
				}
			})) };
			Disabler = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Disable All", "disabler_all", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					o.GetComponent<ObjectRemover>().all = true;
				}
			}).WithDefaultValue(value: false)) });
			Prefab = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Preview Visibility", "prefab_visibility", delegate(GameObject o, ChoiceConfigValue value)
			{
				o.GetComponent<Prefab>().visibility = value.GetValue();
			}).WithOptions("All", "Unlocked", "None").WithDefaultValue(0)) });
			ObjectLayerer = new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Target ID", "layerer_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<Layerer>().target = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Set Layer", "layerer_name", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<Layerer>().layer = LayerMask.NameToLayer(value.GetValue());
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Applied", "layerer_start_applied", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Layerer>().start = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Recursive", "layerer_recursive", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Layerer>().recursive = value.GetValue();
				}).WithDefaultValue(value: true))
			};
			EnviroRegion = new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Environment Type", "enviro_region_type", delegate(GameObject o, ChoiceConfigValue value)
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				string text = value.GetStringValue();
				string text2 = text;
				string text3 = text2;
				if (!(text3 == "WaterS"))
				{
					if (text3 == "WaterRun")
					{
						text = "RunningWater";
					}
				}
				else
				{
					text = "ShallowWater";
				}
				if (Enum.TryParse<EnvironmentTypes>(text, out EnvironmentTypes result3))
				{
					o.GetComponent<EnviroRegion>().environmentType = result3;
				}
			}).WithOptions("Dust", "Grass", "Bone", "WaterS", "Metal", "NoEffect", "Moss", "Sand", "Bell", "WetMetal", "ThinMetal", "Wood", "Silk", "WetWood", "WaterRun", "PeakPuff", "FlowerField").WithDefaultValue(0)) };
			Hook = Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Path", "enemy_path", delegate(GameObject o, IdConfigValue value)
			{
				EnemyHook component37 = o.GetComponent<EnemyHook>();
				if (Object.op_Implicit((Object)(object)component37))
				{
					component37.path = value.GetUnmodifiedValue();
				}
				else
				{
					ObjectHook component38 = o.GetComponent<ObjectHook>();
					component38.path = value.GetUnmodifiedValue();
					component38.prefabPath = value.GetValue();
				}
			}));
			ObjectHook = new List<Architect.Config.Types.ConfigType>(5)
			{
				Hook,
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Child Path", "object_hook_child_path", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<ObjectHook>().childPath = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Start Mode", "object_hook_start", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<ObjectHook>().start = value.GetValue();
				}).WithOptions("Normal", "Inactive", "Active").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Index", "object_hook_index", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<ObjectHook>().index = value.GetValue();
				}).WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Remove Normal Activators", "remove_vanilla_disablers", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						EnemyFixers.KeepActive(o);
						o.RemoveComponent<ActivateIfPlayerdataFalse>();
						o.RemoveComponent<ActivateIfPlayerdataTrue>();
						o.AddComponent<IgnoreDisablers>();
						o.RemoveComponent<Disabler>();
					}
				}).WithDefaultValue(value: false))
			};
			EnemyHook = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Hook,
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Index", "enemy_hook_index", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<EnemyHook>().index = value.GetValue();
				}).WithDefaultValue(0))
			});
			CocoonSpawnPoint = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Disable Vanilla Points", "cocoon_disable_others", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponent<CustomGuidComponent>().overrideAll = value.GetValue();
			}).WithDefaultValue(value: false)) });
			Darkness = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Dark Level", "darkness_level", delegate(GameObject o, IntConfigValue value)
			{
				o.GetComponent<Darkness>().amount = value.GetValue();
			}).WithDefaultValue(2)) });
			Dust = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Time", "dust_time", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<MiscFixers.Dust>().time = value.GetValue();
			}).WithDefaultValue(1f)) });
			AudioPlayer = new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Play on Start", "audio_player_start", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<AudioPlayer>().playOnStart = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "audio_player_cue_type", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<AudioPlayer>().isAtmos = value.GetValue() == 1;
				}).WithDefaultValue(0).WithOptions("Music", "Atmos")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Lock", "audio_player_lock", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<AudioPlayer>().lockMusic = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Audio Cue", "audio_player_cue", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<AudioPlayer>().cueId = value.GetValue();
				}).WithDefaultValue("None"))
			};
			Visible = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Visible", "is_visible", delegate(GameObject o, BoolConfigValue value)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				if (!value.GetValue())
				{
					o.RemoveComponent<MiscFixers.ColorLock>();
					tk2dSprite[] componentsInChildren9 = o.GetComponentsInChildren<tk2dSprite>(true);
					foreach (tk2dSprite val20 in componentsInChildren9)
					{
						Color color5 = ((tk2dBaseSprite)val20).color;
						color5.a = 0f;
						((tk2dBaseSprite)val20).color = color5;
					}
					SpriteRenderer[] componentsInChildren10 = o.GetComponentsInChildren<SpriteRenderer>(true);
					foreach (SpriteRenderer val21 in componentsInChildren10)
					{
						Color color6 = val21.color;
						color6.a = 0f;
						val21.color = color6;
					}
					o.AddComponent<MiscFixers.ColorLock>().permanent = true;
				}
			})) });
			VoidTsunami = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Camera Shake", "void_tsunami_shake", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.RemoveComponentsInChildren<CameraControlAnimationEvents>();
				}
			}).WithDefaultValue(value: true)) });
			Treadmill = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Override Speed", "treadmill_speed", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				float num9 = value.GetValue();
				HeroTreadmill component35 = o.GetComponent<HeroTreadmill>();
				InverseHeroTreadmill component36 = o.GetComponent<InverseHeroTreadmill>();
				if (Object.op_Implicit((Object)(object)component35))
				{
					component35.OnDisable();
					Object.Destroy((Object)(object)component35);
				}
				if (Object.op_Implicit((Object)(object)component36))
				{
					component36.OnDisable();
					Object.Destroy((Object)(object)component36);
				}
				o.GetComponent<Animator>().speed = num9 / 5f;
				o.GetComponent<CogRotationController>().rotationMultiplier = num9 / 5f;
				if (o.transform.localScale.x > 0f)
				{
					num9 = 0f - num9;
				}
				o.GetComponentInChildren<ConveyorBelt>().speed = num9;
			})) });
			DocksLift = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Offset L", "docks_lift_x_l", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<InteractableFixers.BoneCarriage>().leftOffset.x = value.GetValue();
				}).WithDefaultValue(-1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Offset L", "docks_lift_y_l", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<InteractableFixers.BoneCarriage>().leftOffset.y = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Offset R", "docks_lift_x_r", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<InteractableFixers.BoneCarriage>().rightOffset.x = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Offset R", "docks_lift_y_r", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<InteractableFixers.BoneCarriage>().rightOffset.y = value.GetValue();
				}).WithDefaultValue(0f))
			});
			Ventrica = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Decorations", "ventrica_decor", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						for (int num8 = 8; num8 <= 11; num8++)
						{
							((Component)o.transform.GetChild(3).GetChild(num8)).gameObject.SetActive(false);
						}
					}
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Door ID", "ventrica_door_id", delegate(GameObject o, StringConfigValue value)
				{
					((Object)o.transform.GetChild(0)).name = value.GetValue();
					FSMUtility.LocateMyFSM(o, "Tube Travel").FsmVariables.FindFsmString("Door Name").value = value.GetValue();
				}))
			});
			Cocoon = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "cocoon_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					switch (value.GetValue())
					{
					case 1:
						FSMUtility.LocateMyFSM(o, "Break").GetState("Return Currency").DisableAction(0);
						break;
					case 2:
						((Behaviour)FSMUtility.LocateMyFSM(o, "Break")).enabled = false;
						((Component)o.transform.GetChild(1)).gameObject.SetActive(true);
						((Component)o.transform.GetChild(1).GetChild(1)).gameObject.SetActive(false);
						((Component)o.transform.GetChild(1).GetChild(2)).gameObject.SetActive(false);
						((Component)o.transform.GetChild(1).GetChild(3)).gameObject.SetActive(false);
						break;
					}
				}).WithDefaultValue(0).WithOptions("Normal", "Fake", "Unbreakable")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Return Currency/Silk", "cocoon_items", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						FSMUtility.LocateMyFSM(o, "Break").GetState("Return Currency").DisableAction(0);
					}
				}).WithDefaultValue(value: true))
			});
			Teleporter = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Target ID", "weaver_teleporter_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<MiscFixers.WeaverLiftModifier>().target = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "weaver_teleporter_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<MiscFixers.WeaverLiftModifier>().mode = value.GetValue();
				}).WithDefaultValue(0).WithOptions("Top", "Bottom")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Teleport Duration", "weaver_teleporter_duration", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<WeaverLift>().teleportDuration = value.GetValue();
				}))
			});
			VerticalRing = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Move Distance", "vertical_ring_distance", delegate(GameObject o, FloatConfigValue value)
			{
				Extensions.SetLocalPositionY(o.transform.GetChild(3), value.GetValue());
			}).WithDefaultValue(5f)) });
			Chest = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Rosary Count S", "chest_rosaries_s", delegate(GameObject o, IntConfigValue value)
				{
					FSMUtility.LocateMyFSM(o, "Chest Control").FsmVariables.FindFsmInt("Geo Small").Value = value.GetValue();
				}).WithDefaultValue(10)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Rosary Count M", "chest_rosaries_m", delegate(GameObject o, IntConfigValue value)
				{
					FSMUtility.LocateMyFSM(o, "Chest Control").FsmVariables.FindFsmInt("Geo Med").Value = value.GetValue();
				}).WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Rosary Count L", "chest_rosaries_l", delegate(GameObject o, IntConfigValue value)
				{
					FSMUtility.LocateMyFSM(o, "Chest Control").FsmVariables.FindFsmInt("Geo Large").Value = value.GetValue();
				}).WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Shard Count", "chest_shards", delegate(GameObject o, IntConfigValue value)
				{
					FSMUtility.LocateMyFSM(o, "Chest Control").FsmVariables.FindFsmInt("Shards").Value = value.GetValue();
				}).WithDefaultValue(0))
			});
			Item = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Item ID", "item_id", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<CustomPickup>().item = value.GetValue();
				}).WithDefaultValue("Rosary_Set_Small")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Contact Pickup", "item_touch", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<CustomPickup>().touch = value.GetValue();
				}).WithDefaultValue(value: false).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Ignore Limit", "item_ignore_obtained", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<CustomPickup>().ignoreObtained = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Stay Collected", "item_stay", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<CustomPickup>().persistence = value.GetValue();
				}).WithOptions("False", "Bench", "True"))
			});
			CoralNut = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Hide Break", "coral_nut_hide", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					ParticleSystemRenderer[] componentsInChildren8 = o.GetComponentsInChildren<ParticleSystemRenderer>();
					foreach (ParticleSystemRenderer val19 in componentsInChildren8)
					{
						((Renderer)val19).enabled = false;
					}
					Object.Destroy((Object)(object)((Component)o.transform.GetChild(1)).gameObject);
					o.GetComponent<HitResponse>().spawnFling = Array.Empty<SimpleFling>();
					o.RemoveComponent<AudioSource>();
				}
			}).WithDefaultValue(value: false)) });
			LoreTablets = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Text", "tablet_text", delegate(GameObject o, StringConfigValue value)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				o.GetComponentInChildren<BasicNPC>(true).talkText = (LocalisedString[])(object)new LocalisedString[1]
				{
					new LocalisedString("ArchitectMod", value.GetValue())
				};
			}).WithDefaultValue("Sample Text")) });
			DoubleLoreTablet = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Activated", "double_tablet_stay")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Initial Text", "double_tablet_text_1", delegate(GameObject o, StringConfigValue value)
				{
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					o.GetComponentInChildren<BasicNPC>(true).talkText = (LocalisedString[])(object)new LocalisedString[1]
					{
						new LocalisedString("ArchitectMod", value.GetValue())
					};
				}).WithDefaultValue("Sample Text")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Actual Text", "double_tablet_text_2", delegate(GameObject o, StringConfigValue value)
				{
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					((Component)o.transform.GetChild(1)).GetComponentInChildren<BasicNPC>(true).talkText = (LocalisedString[])(object)new LocalisedString[1]
					{
						new LocalisedString("ArchitectMod", value.GetValue())
					};
				}).WithDefaultValue("Sample Text"))
			});
			Bell = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Extra Length", "bell_chain_length", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				Transform transform2 = ((Component)o.transform.GetChild(0).GetChild(0)).transform;
				transform2.position += new Vector3(0f, value.GetValue());
				for (int num6 = 2; num6 < o.transform.GetChild(0).childCount; num6++)
				{
					HingeJoint2D component34 = ((Component)o.transform.GetChild(0).GetChild(num6)).GetComponent<HingeJoint2D>();
					((AnchoredJoint2D)component34).connectedAnchor = ((AnchoredJoint2D)component34).connectedAnchor + new Vector2(0f, value.GetValue() / (float)(o.transform.GetChild(0).childCount - 2));
				}
			})) });
			JellyEgg = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Regen Time", "egg_regen", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<JellyEgg>().regenTime = value.GetValue();
			}).WithDefaultValue(-1f)) });
			NeedolinGate = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Show Strings", "needolin_gate_strings", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
					((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
					((Component)o.transform.GetChild(17)).gameObject.SetActive(false);
					((Component)o.transform.GetChild(25)).gameObject.SetActive(false);
				}
			}).WithDefaultValue(value: true)) });
			JunkPipe = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Terrain Collision", "junk_pipe_terrain", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					((Component)o.transform.GetChild(5)).gameObject.SetActive(false);
					((Component)o.transform.GetChild(6)).gameObject.SetActive(false);
					((Component)o.transform.GetChild(7)).gameObject.SetActive(false);
				}
			}).WithDefaultValue(value: true)) });
			BlackThreader = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(10)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "voider_id", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<BlackThreader>().id = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Effects", "voider_side_effects", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<BlackThreader>().sideEffects = value.GetValue();
				}).WithOptions("All", "Hazard", "Visual", "Audio").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Void Circle Chance", "voider_ball", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<BlackThreader>().chances[0] = Mathf.Abs(value.GetValue());
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Void Shot Chance", "voider_shot", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<BlackThreader>().chances[1] = Mathf.Abs(value.GetValue());
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Void Spew Chance", "voider_vomit", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<BlackThreader>().chances[2] = Mathf.Abs(value.GetValue());
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Void Lash Chance", "voider_whip", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<BlackThreader>().chances[3] = Mathf.Abs(value.GetValue());
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Trigger Mode", "voider_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<BlackThreader>().mode = value.GetValue();
				}).WithOptions("From Start", "Event Only").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Health Multiplier", "voider_hp_mul", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<BlackThreader>().hpMultiplier = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Attack Naturally", "voider_no_attack", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<BlackThreader>().blockAttacks = !value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Require Act 3", "voider_do_check", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<BlackThreader>().requireAct3 = value.GetValue();
				}).WithDefaultValue(value: false))
			});
			Plasmifier = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "plasmifier_id", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<Plasmifier>().id = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Trigger Mode", "plasmifier_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<Plasmifier>().mode = value.GetValue();
				}).WithOptions("From Start", "Event Only").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Heal Amount", "plasmifier_heal", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<Plasmifier>().heal = value.GetValue();
				}).WithDefaultValue(5))
			});
			Shielder = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(15)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "shielder_id", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<Shielder>().id = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Applied", "shielder_start_applied", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().startApplied = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Generic", "shielder_generic", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.GetComponent<Shielder>().extraImmunities.Add((AttackTypes)1);
					}
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Lightning", "shielder_lightning", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.GetComponent<Shielder>().extraImmunities.Add((AttackTypes)9);
					}
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Spell", "shielder_spell", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.GetComponent<Shielder>().extraImmunities.Add((AttackTypes)2);
					}
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Heavy", "shielder_heavy", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.GetComponent<Shielder>().extraImmunities.Add((AttackTypes)16);
					}
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Water", "shielder_water", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToWater = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Lava", "shielder_lava", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToLava = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Coal", "shielder_coal", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToCoal = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Explosions", "shielder_explosions", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToExplosions = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Needle", "shielder_nail", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToNailAttacks = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Spikes", "shielder_spikes", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToSpikes = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Traps", "shielder_traps", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToTraps = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Beams", "shielder_beams", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToBeams = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immune to Hunter Weapons", "shielder_hunter", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Shielder>().immuneToHunterWeapon = value.GetValue();
				}).WithDefaultValue(value: false))
			});
			AnimPlayer = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Clip Name", "anim_clip", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<PlayerAnimPlayer>().clipName = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Duration Override", "anim_duration", delegate(GameObject o, FloatConfigValue value)
				{
					PlayerAnimPlayer component33 = o.GetComponent<PlayerAnimPlayer>();
					component33.overrideAnimTime = true;
					component33.animTime = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Take Control", "anim_take_ctrl", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<PlayerAnimPlayer>().takeCtrl = value.GetValue();
				}).WithDefaultValue(value: true))
			});
			TimeSlower = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(5)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Time Scale", "time_scale", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<TimeSlower>().targetSpeed = value.GetValue();
				}).WithDefaultValue(0.25f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Change Time", "time_change", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<TimeSlower>().changeTime = value.GetValue();
				}).WithDefaultValue(0.1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Wait Time", "time_wait", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<TimeSlower>().waitTime = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Return Time", "time_return", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<TimeSlower>().returnTime = value.GetValue();
				}).WithDefaultValue(0.75f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Prevent Pausing Game", "time_prevent_pausing", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<TimeSlower>().noPause = value.GetValue();
				}).WithDefaultValue(value: true))
			});
			Toll = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Cost", "toll_cost", delegate(GameObject o, IntConfigValue value)
				{
					FSMUtility.LocateMyFSM(o, "Behaviour (special)").FsmVariables.FindFsmInt("Cost").value = Math.Max(1, value.GetValue());
				}).WithDefaultValue(100)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Text", "toll_text", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<MiscFixers.Toll>().text = value.GetValue();
				}).WithDefaultValue("Sample Text"))
			});
			MapStateHook = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Memory", "msh_state", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponent<MapStateHook>().memory = value.GetValue();
			}).WithDefaultValue(value: false)) });
			CameraBorder = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Border Type", "camera_border_type", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<CameraBorder>().type = value.GetValue();
				}).WithOptions("Left", "Right", "Top", "Bottom", "Lock").WithDefaultValue(4)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Active Mode", "camera_border_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<CameraBorder>().activeType = value.GetValue();
				}).WithOptions("Both", "Gameplay", "Binoculars").WithDefaultValue(0))
			});
			Wisp = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Range Multiplier", "wisp_range", delegate(GameObject o, FloatConfigValue value)
			{
				CircleCollider2D component32 = ((Component)o.transform.GetChild(0)).GetComponent<CircleCollider2D>();
				if (value.GetValue() == 0f)
				{
					((Behaviour)component32).enabled = false;
				}
				else
				{
					component32.radius *= value.GetValue();
				}
			}).WithDefaultValue(1f).WithPriority(-1)) });
			AllyWisp = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Range Multiplier", "ally_wisp_range", delegate(GameObject o, FloatConfigValue value)
			{
				CircleCollider2D component31 = ((Component)o.GetComponent<MiscFixers.AllyWisp>().range).GetComponent<CircleCollider2D>();
				if (value.GetValue() == 0f)
				{
					((Behaviour)component31).enabled = false;
				}
				else
				{
					component31.radius *= value.GetValue();
				}
			}).WithDefaultValue(1f).WithPriority(-1)) });
			Roar = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Time", "roar_time", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<RoarEffect>().time = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Size", "roar_size", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<RoarEffect>().small = value.GetValue() == 1;
				}).WithOptions("Large", "Small").WithDefaultValue(0))
			});
			CloseableGates = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Open", "gate_start_open", delegate(GameObject o, BoolConfigValue value)
			{
				Gate component30 = o.GetComponent<Gate>();
				if (Object.op_Implicit((Object)(object)component30))
				{
					if (value.GetValue())
					{
						((UnlockablePropBase)component30).Opened();
					}
				}
				else
				{
					o.GetComponent<PlayMakerFSM>().FsmVariables.FindFsmBool("Start Closed").Value = !value.GetValue();
				}
			}).WithDefaultValue(value: false)) });
			Relay = new List<Architect.Config.Types.ConfigType>(7)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Relay ID", "relay_id", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<Relay>().id = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Reset on Bench", "relay_bench_reset", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Relay>().semiPersistent = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Delay", "relay_delay", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Relay>().delay = value.GetValue();
				}).WithDefaultValue(0f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Relay Chance", "relay_chance", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Relay>().relayChance = value.GetValue();
				}).WithDefaultValue(1f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Trigger on Load", "relay_load_trigger", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Relay>().broadcastImmediately = value.GetValue();
				}).WithDefaultValue(value: false).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Enabled", "relay_start_active", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Relay>().startActivated = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("[Deprecated]", "relay_multiplayer", delegate
				{
				}))
			};
			Timer = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Delay", "timer_start_delay", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Timer>().startDelay = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Repeat Delay", "timer_repeat_delay", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Timer>().repeatDelay = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Random Delay", "timer_rand_delay", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Timer>().randDelay = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Max Calls", "timer_limit", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<Timer>().maxCalls = value.GetValue();
				}))
			});
			Mutable = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Mute Sound", "mutable_muted", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponentInChildren<SoundMaker>().muted = value.GetValue();
			}).WithDefaultValue(value: false).WithPriority(-1)) });
			Coral = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Grown", "coral_start_up", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponent<ActivatingBase>().startActive = value.GetValue();
			}).WithDefaultValue(value: true)) });
			AbilityCrystal = GroupUtils.Merge(Mutable, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Regen Time", "crystal_regen_time", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<AbilityCrystal>().regenTime = value.GetValue();
				}).WithDefaultValue(2.5f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Single Use", "crystal_single_use", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<AbilityCrystal>().singleUse = value.GetValue();
				}).WithDefaultValue(value: false).WithPriority(-1))
			});
			Duplicator = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "duplicator_id", delegate(GameObject o, IdConfigValue value)
			{
				o.GetComponent<ObjectDuplicator>().id = value.GetValue();
			})) });
			Camera = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "camera_view_id", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<CameraObjects.CustomCamera>().id = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Resolution", "camera_resolution", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<CameraObjects.CustomCamera>().resolution = value.GetValue();
				}).WithDefaultValue(1024)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Zoom", "camera_zoom_amount", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<tk2dCamera>().zoomFactor = value.GetValue();
				}).WithDefaultValue(1f))
			});
			Zaprock = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Delay", "zap_delay", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					((Wait)FSMUtility.LocateMyFSM(o, "Control").GetState("Start Pause").Actions[0]).time = FsmFloat.op_Implicit(value.GetValue());
				}).WithDefaultValue(0.25f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Cooldown", "zap_cooldown", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Expected O, but got Unknown
					FsmState state9 = FSMUtility.LocateMyFSM(o, "Control").GetState("Zap Pause");
					WaitRandom val18 = (WaitRandom)state9.Actions[1];
					val18.timeMin = (val18.timeMax = FsmFloat.op_Implicit(value.GetValue()));
					state9.DisableAction(0);
					state9.DisableAction(2);
				}).WithDefaultValue(1f))
			});
			Levers = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Pulled", "lever_stay_pulled")) });
			Buttons = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Pushed", "button_stay_pushed")) });
			Frost = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Freeze Speed", "frost_speed", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<FrostMarker>().frostSpeed = value.GetValue();
			}).WithDefaultValue(10f)) });
			Stretchable = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Scale", "object_scale", delegate(GameObject o, Vector2ConfigValue value)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, Vector2.op_Implicit(o.transform.localScale) * value.GetValue());
			}, delegate(GameObject o, Vector2ConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, Vector2.op_Implicit(o.transform.localScale) * value.GetValue());
			}).WithDefaultValue(Vector2.one)) });
			PlayerBarrier = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Can Slide On", "player_barrier_slider", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.AddComponent<NonSlider>();
				}
			}).WithDefaultValue(value: true)) });
			Updraft = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Width", "updraft_width", delegate(GameObject o, FloatConfigValue value)
				{
					Extensions.SetScaleX(o.transform, Extensions.GetScaleX(o.transform) * value.GetValue());
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					Extensions.SetScaleX(o.transform, Extensions.GetScaleX(o.transform) * value.GetValue());
				}).WithDefaultValue(1.5f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Height", "updraft_height", delegate(GameObject o, FloatConfigValue value)
				{
					Extensions.SetScaleY(o.transform, Extensions.GetScaleY(o.transform) * value.GetValue() * 2f);
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					Extensions.SetScaleY(o.transform, Extensions.GetScaleY(o.transform) * value.GetValue());
				}).WithDefaultValue(5f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Functionality", "updraft_functional", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						PlayMakerFSM component29 = o.GetComponent<PlayMakerFSM>();
						component29.GetState(component29.ActiveStateName).transitions = Array.Empty<FsmTransition>();
					}
				}).WithDefaultValue(value: true))
			});
			Wind = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(9)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Show Particles", "wind_particles", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.GetComponent<Wind>().SetupParticles();
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Wind Speed", "wind_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Wind>().speed = value.GetValue() * 10f;
				}).WithDefaultValue(3f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Affects Player", "wind_affects_player", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Wind>().affectsPlayer = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Affects Enemies", "wind_affects_enemies", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Wind>().affectsEnemies = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Affects Projectiles", "wind_affects_projectiles", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Wind>().affectsProjectiles = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Particle R", "wind_colour_r", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Wind>().r = value.GetValue();
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
				{
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					if (arg3 != 0)
					{
						SpriteRenderer component28 = o.GetComponent<SpriteRenderer>();
						Color color4 = component28.color;
						color4.r = value.GetValue();
						component28.color = color4;
					}
				}).WithDefaultValue(1f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Particle G", "wind_colour_g", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Wind>().g = value.GetValue();
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
				{
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					if (arg3 != 0)
					{
						SpriteRenderer component27 = o.GetComponent<SpriteRenderer>();
						Color color3 = component27.color;
						color3.g = value.GetValue();
						component27.color = color3;
					}
				}).WithDefaultValue(1f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Particle B", "wind_colour_b", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Wind>().b = value.GetValue();
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
				{
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					if (arg3 != 0)
					{
						SpriteRenderer component26 = o.GetComponent<SpriteRenderer>();
						Color color2 = component26.color;
						color2.b = value.GetValue();
						component26.color = color2;
					}
				}).WithDefaultValue(1f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Particle A", "wind_colour_a", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Wind>().a = value.GetValue();
				}).WithDefaultValue(1f).WithPriority(-1))
			});
			Slope = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Slide Speed", "slope_speed", delegate(GameObject o, FloatConfigValue value)
				{
					float value16 = value.GetValue();
					SlideSurface component24 = o.GetComponent<SlideSurface>();
					component24.shallowSlideSpeed *= value16;
					SlideSurface component25 = o.GetComponent<SlideSurface>();
					component25.steepSlideSpeed *= value16;
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Show Particles", "slope_particles", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.GetComponent<SlideSurface>().slideParticles = (ParticleSystem[])(object)new ParticleSystem[3];
					}
				}).WithDefaultValue(value: true))
			});
			Water = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Maggoted", "water_maggot", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<MiscFixers.Water>().maggot = value.GetValue();
				}).WithDefaultValue(value: false).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Voided", "water_void", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<MiscFixers.Water>().abyss = value.GetValue();
					((Behaviour)FSMUtility.LocateMyFSM(((Component)o.transform.GetChild(0)).gameObject, "Volt Travel")).enabled = false;
				}).WithDefaultValue(value: false).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Flow Speed", "water_flow_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<SurfaceWaterRegion>().flowSpeed = value.GetValue();
				}).WithDefaultValue(0f).WithPriority(-1))
			});
			DreamBlock = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Show Particles", "show_particles_dream", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					o.GetComponent<DreamBlock>().SetupParticles();
				}
			}).WithDefaultValue(value: true)) });
			CradlePlat = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(6)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Moved", "cradle_plat_stay").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Move Distance (Y)", "cradle_plat_dist_y", delegate(GameObject o, FloatConfigValue value)
				{
					Extensions.SetLocalPositionY(((Component)o.GetComponent<CrankPlat>().endPoint).transform, value.GetValue());
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Move Distance (X)", "cradle_plat_dist_x", delegate(GameObject o, FloatConfigValue value)
				{
					Extensions.SetLocalPositionX(((Component)o.GetComponent<CrankPlat>().endPoint).transform, value.GetValue());
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Hit Force", "cradle_plat_force", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<CrankPlat>().hitForce = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Max Hit Speed", "cradle_max_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<CrankPlat>().maxHitSpeed = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Max Return Speed", "cradle_max_return", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<CrankPlat>().maxReturnSpeed = value.GetValue();
				}).WithPriority(-1))
			});
			CrumbleHazardStates = new string[3] { "Drop Antic", "Drop", "Return Antic" };
			CrumblePlat = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Respawn on Hazard", "crumble_hazard_respawn", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						PlayMakerFSM fsm12 = FSMUtility.LocateMyFSM(o, "Control");
						string[] crumbleHazardStates = CrumbleHazardStates;
						foreach (string state7 in crumbleHazardStates)
						{
							FsmState state8 = fsm12.GetState(state7);
							state8.transitions = state8.transitions.Where((FsmTransition trans) => trans.EventName != "HAZARD RESPAWNED").ToArray();
						}
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Respawn Time", "crumble_respawn_time", delegate(GameObject o, FloatConfigValue value)
				{
					FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmFloat("Return Time").Value = value.GetValue();
				}).WithDefaultValue(3f))
			});
			SilkSpool = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Stay Used", "spool_used", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.RemoveComponent<PersistentIntItem>();
				}
			}).WithDefaultValue(value: false)) });
			SilkHeart = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Give Silk Heart", "heart_get", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					FSMUtility.LocateMyFSM(o, "Control").GetState("Set Data").DisableAction(0);
				}
			}).WithDefaultValue(value: true)) });
			MaskAndSpool = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Collected", "mask_stay").WithDefaultValue(2)) });
			SilkLever = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Pulled", "silk_lever_stay", delegate(GameObject o, PersistentBoolItem item)
			{
				o.GetComponent<Lever>().persistent = item;
				((PersistentItem<bool>)(object)item).OnSetSaveState += delegate(bool value)
				{
					if (value)
					{
						EventManager.BroadcastEvent(o, "OnPull");
						EventManager.BroadcastEvent(o, "LoadedPulled");
					}
				};
			})) });
			RenderLayer = Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Render Layer", "obj_layer", delegate(GameObject o, IntConfigValue value)
			{
				Renderer[] componentsInChildren7 = o.GetComponentsInChildren<Renderer>();
				foreach (Renderer val17 in componentsInChildren7)
				{
					val17.sortingOrder = value.GetValue();
				}
			}, delegate(GameObject o, IntConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				((Renderer)o.GetComponent<SpriteRenderer>()).sortingOrder = value.GetValue();
			}).WithDefaultValue(0));
			ZOffset = Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Z Offset", "obj_z", delegate(GameObject o, FloatConfigValue value)
			{
				Extensions.SetPositionZ(o.transform, Extensions.GetPositionZ(o.transform) + value.GetValue());
			}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
			{
				if (arg3 == Architect.Config.ConfigurationManager.PreviewContext.Cursor)
				{
					CursorManager.Offset.z += value.GetValue();
				}
				else
				{
					Extensions.SetPositionZ(o.transform, Extensions.GetPositionZ(o.transform) + value.GetValue());
				}
			}).WithDefaultValue(0f));
			Sandcarver = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				ZOffset,
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Appear Range", "sandcarver_range", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<CircleCollider2D>().radius = value.GetValue();
				}).WithDefaultValue(4f))
			});
			CameraView = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(6)
			{
				ZOffset,
				RenderLayer,
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("On UI", "ui_camera_target_on_ui", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<CameraObjects.CustomCameraTarget>().onUI = value.GetValue();
				}).WithDefaultValue(value: false).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("UI Offset", "ui_camera_target_offset", delegate(GameObject o, Vector2ConfigValue value)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: 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)
					CameraObjects.CustomCameraTarget orAddComponent5 = o.GetOrAddComponent<CameraObjects.CustomCameraTarget>();
					Vector2 value15 = value.GetValue();
					orAddComponent5.xOffset = value15.x;
					orAddComponent5.yOffset = value15.y;
				}).WithDefaultValue(Vector2.zero).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("UI Shift With", "ui_camera_target_anchor", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetOrAddComponent<CameraObjects.CustomCameraTarget>().anchorTo = value.GetValue();
				}).WithOptions("None", "LastMask", "LastTool").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("UI Hide with HUD", "ui_camera_target_hide_with_hud", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<CameraObjects.CustomCameraTarget>().ignoreHudOut = !value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1))
			});
			Dialogue = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Dialogue", "shakra_text", delegate(GameObject o, StringConfigValue value)
			{
				o.GetComponent<MiscFixers.Npc>().text = value.GetValue();
			}).WithDefaultValue("Sample Text").WithPriority(-1)) });
			Npcs = GroupUtils.Merge(Visible, GroupUtils.Merge(Dialogue, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Needolin Dialogue", "needolin_on", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.RemoveComponentsInChildren<NeedolinTextOwner>();
					}
				}).WithDefaultValue(value: true)),
				ZOffset
			}));
			Pavo = GroupUtils.Merge(Visible, GroupUtils.Merge(Npcs, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Distance L", "pavo_dist_l", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.Pavo>().walkL = value.GetValue();
				}).WithDefaultValue(2f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Distance R", "pavo_dist_r", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.Pavo>().walkR = value.GetValue();
				}).WithDefaultValue(2f))
			}));
			SeerZi = GroupUtils.Merge(Npcs, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Awake", "zi_awake", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					o.GetComponent<MiscFixers.Zi>().DoWake();
				}
			}).WithDefaultValue(value: true)) });
			MaskMaker = GroupUtils.Merge(Npcs, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Unmasked Dialogue", "mask_maker_unmasked_text", delegate(GameObject o, StringConfigValue value)
			{
				o.GetComponent<MiscFixers.MaskMaker>().unmasked = value.GetValue();
			}).WithDefaultValue("Sample Text").WithPriority(-1)) });
			Shakra = GroupUtils.Merge(Npcs, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Attack Enemies", "shakra_attack", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					Object.Destroy((Object)(object)FSMUtility.LocateMyFSM(o, "Attack Enemies"));
				}
			}).WithDefaultValue(value: true)) });
			Sherma = GroupUtils.Merge(Npcs, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Start State", "sherma_awake", delegate(GameObject o, ChoiceConfigValue value)
			{
				o.GetComponent<MiscFixers.Sherma>().startState = value.GetValue();
			}).WithOptions("Idle", "Asleep", "Singing").WithDefaultValue(0)) });
			Caretaker = GroupUtils.Merge(Npcs, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Call Out", "caretaker_call", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponent<MiscFixers.Caretaker>().hail = value.GetValue();
			}).WithDefaultValue(value: false)) });
			Silkfly = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(3)
			{
				ZOffset,
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Direction", "silkfly_x", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.Silkfly>().xOffset = value.GetValue();
				}).WithDefaultValue(5f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Direction", "silkfly_y", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.Silkfly>().yOffset = value.GetValue();
				}).WithDefaultValue(5f))
			});
			Fayforn = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Feather Effect", "makes_snow", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						Transform val16 = o.transform.Find("feather_loop");
						if (Object.op_Implicit((Object)(object)val16))
						{
							Object.Destroy((Object)(object)((Component)val16).gameObject);
						}
					}
				}).WithDefaultValue(value: true)),
				ZOffset
			});
			BlurPlane = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { ZOffset });
			HeatSpeed = Shader.PropertyToID("_SpeedY");
			HeatPlane = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Scale", "heat_effect_scale", delegate(GameObject o, Vector2ConfigValue value)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_0019: 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)
					Vector2 value14 = value.GetValue();
					Extensions.SetScaleX(o.transform, Extensions.GetScaleX(o.transform) * value14.x);
					Extensions.SetScaleZ(o.transform, Extensions.GetScaleZ(o.transform) * value14.y);
				}, delegate(GameObject o, Vector2ConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					Extensions.SetScale2D(o.transform, Vector2.op_Implicit(o.transform.localScale) * value.GetValue());
				}).WithDefaultValue(Vector2.one)),
				ZOffset,
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Speed", "heat_speed", delegate(GameObject o, FloatConfigValue value)
				{
					MeshRenderer component23 = o.GetComponent<MeshRenderer>();
					((Renderer)component23).material.SetFloat(HeatSpeed, -0.5f * value.GetValue());
				}).WithDefaultValue(1f).WithPriority(-1))
			});
			Decorations = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2) { RenderLayer, ZOffset });
			StretchDecor = GroupUtils.Merge(Stretchable, GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>()));
			StretchColourDecor = GroupUtils.Merge(StretchDecor, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ColourConfigType("Colour", "png_sprite_colour", delegate(GameObject o, ColourConfigValue value)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				o.GetComponentInChildren<SpriteRenderer>().color = value.GetValue();
			}, alpha: true).WithDefaultValue(Color.white).WithPriority(-1)) });
			Vines = GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Damage Player", "vines_hurt_player", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.RemoveComponent<CustomDamager>();
				}
			}).WithDefaultValue(value: true)) });
			PersistentBreakable = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Broken", "breakable_stay")) });
			Statue = GroupUtils.Merge(PersistentBreakable, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Hits To Break", "statue_total_hits", delegate(GameObject o, IntConfigValue value)
				{
					BreakableHolder component22 = o.GetComponent<BreakableHolder>();
					component22.totalHits = (component22.hitsLeft = value.GetValue());
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Shards Per Hit", "statue_shards_per", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<BreakableHolder>().payoutPerHit = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Final Hit Shards", "statue_shards_final", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<BreakableHolder>().finalPayout = value.GetValue();
				}))
			});
			BodySack = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Drop Corpse", "corpse_in_bag", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.RemoveComponentsInChildren<BreakableGenerateCorpse>();
				}
			}).WithDefaultValue(value: true)) });
			IsBreakable = Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Breakable", "breakable_on", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.RemoveComponentsInChildren<Breakable>();
				}
			}).WithDefaultValue(value: true));
			BreakableDecor = GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>(1) { IsBreakable });
			WispLanterns = GroupUtils.Merge(Bell, GroupUtils.Merge(PersistentBreakable, new List<Architect.Config.Types.ConfigType>(1) { IsBreakable }));
			BreakableWall = GroupUtils.Merge(PersistentBreakable, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Required Hits", "breakable_hits", delegate(GameObject o, IntConfigValue value)
			{
				FSMUtility.LocateMyFSM(o, "breakable_wall_v2").FsmVariables.FindFsmInt("Hits").Value = value.GetValue();
			}).WithDefaultValue(4)) });
			ExplodingWall = GroupUtils.Merge(PersistentBreakable, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Include Wall", "exploding_wall_wall", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					((Behaviour)o.GetComponent<BoxCollider2D>()).enabled = false;
					((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
					((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
					((Component)o.transform.GetChild(3)).gameObject.SetActive(false);
				}
			}).WithDefaultValue(value: true)) });
			LifebloodCocoons = GroupUtils.Merge(PersistentBreakable, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Lifeseed Count", "lifeblood_count", delegate(GameObject o, IntConfigValue value)
			{
				FlingPrefab val15 = o.GetComponent<HealthCocoon>().flingPrefabs[2];
				val15.MinAmount = (val15.MaxAmount = value.GetValue());
			}).WithDefaultValue(2).WithPriority(-1)) });
			TrackPoint = new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Track ID", "track_id", delegate(GameObject o, IdConfigValue value)
			{
				o.GetComponent<SplineObjects.SplinePoint>().id = value.GetValue();
			}).WithDefaultValue("1").WithPriority(-1)) };
			TrackStartPoint = GroupUtils.Merge(Visible, GroupUtils.Merge(TrackPoint, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Speed", "track_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<SplineObjects.Spline>().speed = value.GetValue();
				}).WithDefaultValue(10f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ColourConfigType("Colour", "track_colour", delegate(GameObject o, ColourConfigValue value)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					o.GetComponent<SplineObjects.Spline>().LineColour = value.GetValue();
				}, alpha: true).WithDefaultValue(new Color(1f, 1f, 1f, 0.1f))),
				ZOffset
			}));
			Terrain = LayerMask.NameToLayer("Terrain");
			Default = LayerMask.NameToLayer("Default");
			Colliders = GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Collision Type", "collider_type", delegate(GameObject o, ChoiceConfigValue value)
				{
					switch (value.GetValue())
					{
					case 0:
						o.RemoveComponentsInChildren<Collider2D>();
						break;
					case 1:
					{
						o.layer = Default;
						Collider2D componentInChildren7 = o.GetComponentInChildren<Collider2D>();
						componentInChildren7.isTrigger = true;
						((Component)componentInChildren7).gameObject.AddComponent<CustomDamager>().damageAmount = 1;
						break;
					}
					case 2:
						o.GetComponentInChildren<Collider2D>().isTrigger = false;
						o.layer = Terrain;
						break;
					case 3:
					{
						o.layer = Terrain;
						Collider2D componentInChildren6 = o.GetComponentInChildren<Collider2D>();
						((Component)componentInChildren6).gameObject.AddComponent<PlatformEffector2D>().surfaceArc = 120f;
						componentInChildren6.isTrigger = false;
						componentInChildren6.usedByEffector = true;
						break;
					}
					case 4:
					{
						o.layer = Default;
						Collider2D[] componentsInChildren6 = o.GetComponentsInChildren<Collider2D>();
						foreach (Collider2D val14 in componentsInChildren6)
						{
							val14.isTrigger = false;
							((Component)val14).gameObject.layer = Default;
						}
						break;
					}
					}
				}).WithOptions("None", "Hazard", "Solid", "Semi-Solid", "Barrier")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Fallthrough Time", "collider_fallthrough", delegate(GameObject o, FloatConfigValue value)
				{
					((Component)o.GetComponentInChildren<Collider2D>()).gameObject.AddComponent<Fallthrough>().fallthroughTime = value.GetValue();
				}))
			});
			BellPlat3 = GroupUtils.Merge(Colliders, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Signs", "show_signs", delegate(GameObject o, BoolConfigValue value)
			{
				for (int n = 0; n < 3; n++)
				{
					if (!value.GetValue())
					{
						((Component)o.transform.GetChild(1).GetChild(n)).gameObject.SetActive(false);
					}
				}
			}).WithDefaultValue(value: true)) });
			AlphaColour = Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour A", "colour_alpha", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer component21 = o.GetComponent<SpriteRenderer>();
				Color color = component21.color;
				color.a = value.GetValue();
				component21.color = color;
			}).WithDefaultValue(1f));
			Colours = GroupUtils.Merge(Stretchable, GroupUtils.Merge(Colliders, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ColourConfigType("Colour", "sprite_colour", delegate(GameObject o, ColourConfigValue value)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				o.GetComponent<SpriteRenderer>().color = value.GetValue();
			}, alpha: true, delegate(GameObject o, ColourConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
			{
				//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_0012: 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)
				if (arg3 != 0)
				{
					Color value13 = value.GetValue();
					if (value13.a < 0.1f)
					{
						value13.a = 0.1f;
					}
					o.GetComponent<SpriteRenderer>().color = value13;
				}
			}).WithDefaultValue(Color.white)) }));
			Line = GroupUtils.Merge(Colliders, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Point Set ID", "point_id", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<LineObject>().id = value.GetValue();
				}).WithDefaultValue("1").WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Visual Width", "line_width", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<LineObject>().width = value.GetValue();
				}).WithDefaultValue(0.2f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ColourConfigType("Colour", "line_colour", delegate(GameObject o, ColourConfigValue value)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					o.GetComponent<LineObject>().LineColour = value.GetValue();
				}, alpha: true).WithDefaultValue(Color.white))
			});
			Colourer = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(6)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "colourer_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<ObjectColourer>().targetId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Applied", "colourer_active", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ObjectColourer>().startApplied = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ColourConfigType("Colour RGB", "colourer_colour_set", delegate(GameObject o, ColourConfigValue value)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					o.GetComponent<ObjectColourer>().Colour = value.GetValue();
				}, alpha: false).WithDefaultValue(Color.white)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour A", "colourer_alpha", delegate(GameObject o, FloatConfigValue value)
				{
					ObjectColourer component20 = o.GetComponent<ObjectColourer>();
					component20.useAlphaByDefault = true;
					component20.a = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Colour Particles", "colourer_particles", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<ObjectColourer>().particles = value.GetValue();
				}).WithOptions("True", "False", "Only").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Tint Mode", "colourer_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<ObjectColourer>().mode = value.GetValue();
				}).WithOptions("Multiply", "Set", "Brighten").WithDefaultValue(0))
			});
			Gravity = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Gravity Scale", "gravity_scale", delegate(GameObject o, FloatConfigValue value)
			{
				o.AddComponent<GravityLock>().level = value.GetValue();
			})) });
			TriggerActivator = GroupUtils.Merge(Gravity, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Trigger Layer", "activator_layer", delegate(GameObject o, IntConfigValue value)
			{
				o.GetComponent<MiscFixers.TriggerActivator>().layer = value.GetValue();
			})) });
			Kratt = GroupUtils.Merge(TriggerActivator, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Interactable", "kratt_interactable", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					((Behaviour)o.GetComponent<PlayMakerNPC>()).enabled = false;
				}
			}).WithDefaultValue(value: false)) });
			CoralSpike = GroupUtils.Merge(PersistentBreakable, GroupUtils.Merge(TriggerActivator, new List<Architect.Config.Types.ConfigType>()));
			FakePerformance = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Range Multiplier", "perform_range", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<FakePerformanceRegion>().rangeMult = value.GetValue();
			}).WithDefaultValue(1f)) });
			PlayerDataSetter = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Data ID", "pd_id", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<PlayerDataSetter>().dataName = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Set/Compare Value", "pd_value", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<PlayerDataSetter>().value = value.GetValue();
				}))
			});
			Fleas = GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Fly Away", "flea_flee", delegate(GameObject o, BoolConfigValue value)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				if (!value.GetValue())
				{
					FsmState state6 = FSMUtility.LocateMyFSM(o, "Call Out").GetState("Leave Antic");
					state6.transitions = Array.Empty<FsmTransition>();
					((Tk2dPlayAnimationWithEvents)state6.actions[2]).clipName = FsmString.op_Implicit("RescueToFly");
				}
			}).WithDefaultValue(value: true)) });
			Benches = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Save Respawn", "bench_spawn", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						FsmState state5 = o.GetComponentsInChildren<PlayMakerFSM>().First((PlayMakerFSM fsm) => fsm.FsmName == "Bench Control").GetState("Rest Burst");
						state5.DisableAction(9);
						state5.DisableAction(10);
						state5.DisableAction(11);
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new Vector3ConfigType("Sit Offset", "bench_offset", delegate(GameObject o, Vector3ConfigValue value)
				{
					//IL_003d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0043: Unknown result type (might be due to invalid IL or missing references)
					//IL_0048: Unknown result type (might be due to invalid IL or missing references)
					FsmVector3 val13 = o.GetComponentsInChildren<PlayMakerFSM>().First((PlayMakerFSM fsm) => fsm.FsmName == "Bench Control").FsmVariables.FindFsmVector3("Adjust Vector");
					val13.Value += value.GetValue();
				}).WithDefaultValue(Vector3.zero))
			});
			FullBellBench = GroupUtils.Merge(Benches, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Cost", "bell_bench_cost", delegate(GameObject o, IntConfigValue value)
			{
				CostReference val12 = ScriptableObject.CreateInstance<CostReference>();
				((IntReference)val12).value = value.GetValue();
				FSMUtility.LocateMyFSM(((Component)o.transform.GetChild(14)).gameObject, "Unlock Behaviour").FsmVariables.FindFsmObject("Cost Reference").Value = (Object)(object)val12;
			}).WithDefaultValue(30)) });
			WalkTarget = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Speed Override", "walk_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<WalkTarget>().speed = Mathf.Abs(value.GetValue());
				}).WithPriority(1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "walk_anim", delegate(GameObject o, ChoiceConfigValue value)
				{
					WalkTarget component19 = o.GetComponent<WalkTarget>();
					component19.anim = value.GetStringValue();
					WalkTarget walkTarget = component19;
					int value12 = value.GetValue();
					if (1 == 0)
					{
					}
					float speed = value12 switch
					{
						1 => 8.5f, 
						2 => 20f, 
						_ => 6f, 
					};
					if (1 == 0)
					{
					}
					walkTarget.speed = speed;
				}).WithDefaultValue(0).WithOptions("Walk", "Run", "Sprint"))
			});
			BellBench = GroupUtils.Merge(Benches, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Range", "bench_range", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScaleX(o.transform.GetChild(1), Extensions.GetScaleX(o.transform.GetChild(1)) * value.GetValue());
				Extensions.SetScaleX(o.transform.GetChild(2), Extensions.GetScaleX(o.transform.GetChild(2)) * value.GetValue());
				Extensions.SetScaleX(o.transform.GetChild(3), Extensions.GetScaleX(o.transform.GetChild(3)) * value.GetValue());
				Extensions.SetScaleX(o.transform.GetChild(4), Extensions.GetScaleX(o.transform.GetChild(4)) * value.GetValue());
				BoxCollider2D component18 = o.GetComponent<BoxCollider2D>();
				component18.size = Extensions.Where(component18.size, (float?)(component18.size.x * value.GetValue()), (float?)null);
			})) });
			ObjectSpinner = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "spinner_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<ObjectSpinner>().targetId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Rotation Speed", "spinner_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectSpinner>().speed = value.GetValue();
				}).WithDefaultValue(100f))
			});
			FsmHook = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(5)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "fsm_hook_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<FsmHook>().targetId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Index", "fsm_hook_index", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<FsmHook>().index = value.GetValue();
				}).WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("FSM Name", "fsm_hook_name", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<FsmHook>().fsmName = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Target State", "fsm_hook_state", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<FsmHook>().stateName = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Detection Mode", "fsm_hook_target_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<FsmHook>().inject = value.GetValue() == 1;
				}).WithOptions("Observe", "Inject").WithDefaultValue(0))
			});
			ComponentHook = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(5)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "component_hook_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<ComponentHook>().id = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Component Name", "component_hook_name", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<ComponentHook>().componentName = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Recursive", "component_hook_recursive", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ComponentHook>().recursive = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "component_hook_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<ComponentHook>().mode = value.GetValue();
				}).WithOptions("Destroy", "Disable", "Enable", "None").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Field Name", "component_hook_field", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<ComponentHook>().fieldName = value.GetValue();
				}))
			});
			ObjectAnchor = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(11)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "anchor_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().targetId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Parent ID (Optional)", "anchor_parent", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().parentId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Path Distance", "anchor_dist", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().trackDistance = value.GetValue();
				}).WithDefaultValue(10f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Distance", "anchor_start_dist", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().startOffset = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Move Speed", "anchor_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().speed = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Path Rotation", "anchor_rot", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().startRotation = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Path Rotation over Time", "anchor_rot_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().rotationSpeed = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Smoothing", "anchor_smoothing", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().smoothing = value.GetValue();
				}).WithDefaultValue(0.5f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Pause Time", "anchor_pause_time", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().pauseTime = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Stick Player", "anchor_stick", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().stickPlayer = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Moving", "anchor_moving", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ObjectAnchor>().moving = value.GetValue();
				}).WithDefaultValue(value: true))
			});
			ObjectMover = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(8)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Object ID", "mover_target", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<ObjectMover>().targetId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Offset", "mover_offset", delegate(GameObject o, Vector2ConfigValue value)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: 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)
					ObjectMover component17 = o.GetComponent<ObjectMover>();
					Vector2 value11 = value.GetValue();
					component17.xOffset = value11.x;
					component17.yOffset = value11.y;
				}).WithDefaultValue(Vector2.zero)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Rotation", "mover_rot", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectMover>().rotation = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Clear Velocity", "mover_clear_vel", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ObjectMover>().clearVelocity = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Move X", "mover_do_x", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ObjectMover>().moveX = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Move Y", "mover_do_y", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ObjectMover>().moveY = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Position Source", "mover_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<ObjectMover>().moveMode = value.GetValue();
				}).WithOptions("Mover", "Self", "Player", "Absolute").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IdConfigType("Position Source ID", "mover_mode_2", delegate(GameObject o, IdConfigValue value)
				{
					o.GetComponent<ObjectMover>().moveTarget = value.GetValue();
				}).WithPriority(1))
			});
			Invincible = Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Invincible", "invulnerable", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					o.AddComponent<EnemyInvulnerabilityMarker>();
				}
			}));
			SimpleEnemies = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(11)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Shell Shard Drops", "shell_shard", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponentInChildren<HealthManager>(true).SetShellShards(value.GetValue());
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Small Rosary Drops", "small_money", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponentInChildren<HealthManager>(true).SetGeoSmall(value.GetValue());
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Medium Rosary Drops", "med_money", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponentInChildren<HealthManager>(true).SetGeoMedium(value.GetValue());
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Large Rosary Drops", "large_money", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponentInChildren<HealthManager>(true).SetGeoLarge(value.GetValue());
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Fling Drops", "fling_money", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponentInChildren<HealthManager>(true).megaFlingGeo = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Give Silk", "give_silk", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponentInChildren<HealthManager>(true).doNotGiveSilk = !value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Can Pogo On", "enemy_can_pogo", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						Transform[] componentsInChildren5 = o.GetComponentsInChildren<Transform>(true);
						foreach (Transform val11 in componentsInChildren5)
						{
							((Component)val11).gameObject.AddComponent<NonBouncer>();
						}
					}
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Z Offset", "enemy_z", delegate(GameObject o, FloatConfigValue value)
				{
					SetZ component16 = o.GetComponent<SetZ>();
					if (Object.op_Implicit((Object)(object)component16))
					{
						component16.z += value.GetValue();
					}
					Extensions.SetPositionZ(o.transform, Extensions.GetPositionZ(o.transform) + value.GetValue());
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
				{
					if (arg3 == Architect.Config.ConfigurationManager.PreviewContext.Cursor)
					{
						CursorManager.Offset.z += value.GetValue();
					}
					else
					{
						Extensions.SetPositionZ(o.transform, Extensions.GetPositionZ(o.transform) + value.GetValue());
					}
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Recoil Speed", "enemy_recoil_speed", delegate(GameObject o, FloatConfigValue value)
				{
					Recoil component15 = o.GetComponent<Recoil>();
					if (Object.op_Implicit((Object)(object)component15))
					{
						component15.SetRecoilSpeed(value.GetValue());
					}
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Increment Journal", "enemy_increment_journal", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.AddComponent<JournalKillDisablerMarker>();
					}
				})),
				Invincible
			});
			Garpid = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Loop", "garpid_loop", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						PlayMakerFSM fsm11 = FSMUtility.LocateMyFSM(o, "Control");
						fsm11.GetState("Dormant").AddAction(delegate
						{
							fsm11.SendEvent("ALERT");
						}, -1, everyFrame: false);
					}
				}).WithDefaultValue(value: true)),
				Invincible
			});
			NonPersistentEnemies = GroupUtils.Merge(SimpleEnemies, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Health", "enemy_hp", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponentInChildren<HealthManager>(true).hp = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Enable Health Scaling", "enemy_hp_scale", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.AddComponent<EnemyFixers.DisableHealthScaling>();
					}
				}).WithDefaultValue(value: true))
			});
			Enemies = GroupUtils.Merge(NonPersistentEnemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Dead", "enemy_stay_dead", delegate(GameObject o, PersistentBoolItem item)
			{
				((PersistentItem<bool>)(object)item).OnSetSaveState += delegate(bool b)
				{
					o.GetComponent<HealthManager>().isDead = b;
					if (b)
					{
						item.SetValueOverride(true);
					}
				};
				((PersistentItem<bool>)(object)item).OnGetSaveState += delegate(out bool b)
				{
					b = o.GetComponent<HealthManager>().isDead;
				};
			})) });
			Lilypad = GroupUtils.Merge(NonPersistentEnemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Is Trap", "nuphar_mode", delegate(GameObject o, ChoiceConfigValue value)
			{
				int value10 = value.GetValue();
				FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmBool("Is Enemy").value = value10 switch
				{
					2 => Random.value > 0.5f, 
					0 => true, 
					_ => false, 
				};
			}).WithOptions("True", "False", "Random").WithDefaultValue(2)) });
			Squirm = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Hide Range", "squirm_hide_range", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<EnemyFixers.Squirm>().hideRange.radius = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Needolin Range", "squirm_needolin_range", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<EnemyFixers.Squirm>().musicRange.radius = value.GetValue();
				}).WithDefaultValue(5f))
			});
			Hornfly = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Hop Distance (L/R)", "hornfly_hop_range", delegate(GameObject o, Vector2ConfigValue value)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				o.GetComponent<EnemyFixers.Hornfly>().hopDistance = value.GetValue();
			}).WithDefaultValue(new Vector2(4f, 4f))) });
			Aknids = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Emit Acid", "aknids_acid", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					PlayMakerFSM fsm10 = FSMUtility.LocateMyFSM(o, "Control");
					fsm10.GetState("Break")?.DisableAction(0);
					fsm10.GetState("Shake")?.DisableAction(3);
				}
			}).WithDefaultValue(value: true)) });
			Karaka = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Idle", "karaka_idle", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					o.GetComponent<EnemyFixers.Karaka>().stayIdle = true;
				}
			}).WithDefaultValue(value: true)) });
			Aknid = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Spit Attack", "aknid_cut_attack", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					PlayMakerFSM fsm9 = FSMUtility.LocateMyFSM(o, "Control");
					fsm9.GetState("Choice").DisableAction(0);
				}
			}).WithDefaultValue(value: false)) });
			AknidMother = GroupUtils.Merge(Aknids, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Spawn Children", "aknid_mother_child", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						PlayMakerFSM fsm8 = FSMUtility.LocateMyFSM(o, "Control");
						fsm8.GetState("Hatchling").DisableAction(1);
						EnemyDeathEffects component14 = o.GetComponent<EnemyDeathEffects>();
						component14.PreInstantiate();
						FSMUtility.LocateMyFSM(((Component)component14.GetInstantiatedCorpse((AttackTypes)1).transform.GetChild(0)).gameObject, "Control").GetState("State 1").DisableAction(1);
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Custom Sounds", "aknid_mother_sound", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.GetComponent<EnemyFixers.AknidMother>().active = true;
					}
				}).WithDefaultValue(value: true))
			});
			Furm = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Silver Chance", "furm_silver", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				FsmState state4 = FSMUtility.LocateMyFSM(o, "Control").GetState("Silver?");
				state4.DisableAction(1);
				SendRandomEventV4 val10 = (SendRandomEventV4)state4.actions[2];
				((FsmStateAction)val10).enabled = true;
				float num2 = Mathf.Clamp(value.GetValue(), 0f, 1f);
				val10.weights[0] = FsmFloat.op_Implicit(1f - num2);
				val10.weights[1] = FsmFloat.op_Implicit(num2);
			}).WithDefaultValue(0f)) });
			WingedFurm = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Target Offset", "winged_furm_offset", delegate(GameObject o, Vector2ConfigValue value)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				FSMUtility.LocateMyFSM(o, "Tween").FsmVariables.FindFsmVector3("Move Pos").Value = Vector2.op_Implicit(value.GetValue());
			}).WithDefaultValue(new Vector2(0f, 5f))) });
			YPatroller = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Target Y Offset", "patroller_y", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<EnemyFixers.PatrollerFix>().yOffset = value.GetValue();
			}).WithDefaultValue(0f).WithPriority(-1)) });
			Patroller = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Target Offset", "patroller_offset", delegate(GameObject o, Vector2ConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: 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)
				EnemyFixers.PatrollerFix component13 = o.GetComponent<EnemyFixers.PatrollerFix>();
				Vector2 value9 = value.GetValue();
				component13.xOffset = value9.x;
				component13.yOffset = value9.y;
			}).WithDefaultValue(new Vector2(5f, 0f)).WithPriority(-1)) });
			HugeFlea = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Count as Flea", "huge_flea_count", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					FSMUtility.LocateMyFSM(o, "Control").GetState("Stun").DisableAction(0);
				}
			}).WithDefaultValue(value: true)) });
			Gromling = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Constant Ambush", "gromling_constant", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						PlayMakerFSM fsm7 = FSMUtility.LocateMyFSM(o, "Control");
						fsm7.GetState("Ambush Ready").AddAction(delegate
						{
							fsm7.SendEvent("AMBUSH");
						}, -1, everyFrame: false);
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Hide Time", "gromling_hide", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_002c: Expected O, but got Unknown
					PlayMakerFSM fsm6 = FSMUtility.LocateMyFSM(o, "Control");
					float value8 = value.GetValue();
					WaitRandom val9 = (WaitRandom)fsm6.GetState("Dig Away Pause").actions[0];
					val9.timeMin = FsmFloat.op_Implicit(value8);
					val9.timeMax = FsmFloat.op_Implicit(value8);
				}).WithDefaultValue(1f))
			});
			Grom = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Heal", "grom_heal", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					PlayMakerFSM fsm5 = FSMUtility.LocateMyFSM(o, "Control");
					fsm5.GetState("Reparent").DisableAction(2);
				}
			}).WithDefaultValue(value: false)) });
			Slowdown = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Death Slowdown", "boss_slowdown", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.GetOrAddComponent<EnemyFixers.DisableDeathSlowdown>();
					EnemyDeathEffects componentInChildren5 = o.GetComponentInChildren<EnemyDeathEffects>(true);
					if (Object.op_Implicit((Object)(object)componentInChildren5))
					{
						componentInChildren5.PreInstantiate();
						GameObject instantiatedCorpse = componentInChildren5.GetInstantiatedCorpse((AttackTypes)1);
						if (Object.op_Implicit((Object)(object)instantiatedCorpse))
						{
							instantiatedCorpse.GetOrAddComponent<EnemyFixers.DisableDeathSlowdown>();
						}
					}
				}
			}).WithDefaultValue(value: true)) });
			Bosses = GroupUtils.Merge(Slowdown, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Show Boss Title", "boss_title", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.GetOrAddComponent<EnemyFixers.DisableBossTitle>();
				}
			}).WithDefaultValue(value: true)) });
			FourthChorus = GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Spawn Platforms", "boss_plats", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponent<EnemyFixers.FourthChorus>().doPlats = value.GetValue();
			}).WithDefaultValue(value: true)) });
			DamagesEnemies = Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Damages Enemies", "damages_enemies", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.RemoveComponentsInChildren<DamageEnemies>();
				}
			}));
			Damager = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				DamagesEnemies,
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Damage Amount", "damager_amount", delegate(GameObject o, IntConfigValue value)
				{
					DamageHero[] componentsInChildren4 = o.GetComponentsInChildren<DamageHero>(true);
					foreach (DamageHero val8 in componentsInChildren4)
					{
						val8.SetDamageAmount(value.GetValue());
					}
				}))
			});
			GarmondBoss = GroupUtils.Merge(Slowdown, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Lethal Damage", "garmond_lethal", delegate(GameObject o, BoolConfigValue value)
				{
					//IL_0023: Unknown result type (might be due to invalid IL or missing references)
					//IL_002a: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					if (value.GetValue())
					{
						DamageHero[] componentsInChildren3 = o.GetComponentsInChildren<DamageHero>(true);
						foreach (DamageHero val7 in componentsInChildren3)
						{
							val7.damagePropertyFlags = (DamagePropertyFlags)(val7.damagePropertyFlags & -3);
						}
					}
				}).WithDefaultValue(value: true)),
				DamagesEnemies
			});
			ShakraBoss = GroupUtils.Merge(Slowdown, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Lethal Damage", "shakra_lethal", delegate(GameObject o, BoolConfigValue value)
			{
				//IL_006e: 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_0076: Unknown result type (might be due to invalid IL or missing references)
				if (value.GetValue())
				{
					PlayMakerFSM val5 = FSMUtility.LocateMyFSM(o, "Attack Enemies");
					FsmGameObject proj = val5.FsmVariables.FindFsmGameObject("Projectile");
					val5.GetState("Throw 2").AddAction(delegate
					{
						//IL_0012: Unknown result type (might be due to invalid IL or missing references)
						//IL_0019: Unknown result type (might be due to invalid IL or missing references)
						//IL_001a: Unknown result type (might be due to invalid IL or missing references)
						DamageHero componentInChildren4 = proj.Value.GetComponentInChildren<DamageHero>(true);
						componentInChildren4.damagePropertyFlags = (DamagePropertyFlags)(componentInChildren4.damagePropertyFlags & -3);
					}, 4, everyFrame: false);
					DamageHero[] componentsInChildren2 = o.GetComponentsInChildren<DamageHero>(true);
					foreach (DamageHero val6 in componentsInChildren2)
					{
						val6.damagePropertyFlags = (DamagePropertyFlags)(val6.damagePropertyFlags & -3);
					}
				}
			}).WithDefaultValue(value: true)) });
			LeafRoller = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Hidden", "hidden_leaf_roller", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					tk2dSpriteAnimator component12 = o.GetComponent<tk2dSpriteAnimator>();
					component12.defaultClipId = component12.GetClipIdByName("Hidden");
				}
			}).WithDefaultValue(value: false)) });
			CameraShaker = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Shake Type", "camera_shake_type", delegate(GameObject o, ChoiceConfigValue value)
			{
				o.GetComponent<CameraShaker>().shakeType = value.GetValue();
			}).WithOptions("Tiny", "Small", "Medium", "Large").WithDefaultValue(2)) });
			SavageBeastfly = GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>(2)
			{
				DamagesEnemies,
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Start Phase", "beastfly_phase", delegate(GameObject o, ChoiceConfigValue value)
				{
					int value7 = value.GetValue();
					if (value7 != 0)
					{
						FsmState state3 = FSMUtility.LocateMyFSM(o, "Control").GetState("Set HP");
						state3.DisableAction(1);
						if (value7 == 2)
						{
							state3.DisableAction(3);
						}
					}
				}).WithOptions("Phase 1", "Phase 2", "Phase 3").WithDefaultValue(0).WithPriority(-1))
			});
			MossMother = GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Follow Player", "moss_mother_align", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					FSMUtility.LocateMyFSM(o, "Control").GetState("Idle").DisableAction(0);
				}
			}).WithDefaultValue(value: true)) });
			LastJudge = GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Start Phase", "lj_phase", delegate(GameObject o, ChoiceConfigValue value)
			{
				int value6 = value.GetValue();
				if (value6 != 0)
				{
					PlayMakerFSM val4 = FSMUtility.LocateMyFSM(o, "Control");
					FsmState state2 = val4.GetState("Init");
					state2.DisableAction(12);
					state2.DisableAction(13);
					val4.FsmVariables.FindFsmInt("HP P2").Value = int.MaxValue;
					if (value6 == 2)
					{
						val4.FsmVariables.FindFsmInt("HP P3").Value = int.MaxValue;
					}
				}
			}).WithOptions("Phase 1", "Phase 2", "Phase 3").WithDefaultValue(0)) });
			LastClaw = GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Throw Attack", "lc_throw", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					FsmState state = FSMUtility.LocateMyFSM(o, "Control").GetState("Attack Choice");
					state.actions[4].enabled = true;
				}
			}).WithDefaultValue(value: false)) });
			Wakeable = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Awake", "mossgrub_walk", delegate(GameObject o, BoolConfigValue value)
			{
				EnemyFixers.Wakeable component11 = o.GetComponent<EnemyFixers.Wakeable>();
				if (value.GetValue())
				{
					component11.DoWake();
				}
				else
				{
					component11.DoUnwake();
				}
			}).WithDefaultValue(value: true)) });
			WakeableBosses = GroupUtils.Merge(Wakeable, GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>()));
			Moorwing = GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>(1) { DamagesEnemies });
			Boran = GroupUtils.Merge(Wakeable, new List<Architect.Config.Types.ConfigType>(1) { DamagesEnemies });
			Velocity = GroupUtils.Merge(Gravity, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Velocity", "velocity_apply_x", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetOrAddComponent<VelocityApplier>().x = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Velocity", "velocity_apply_y", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetOrAddComponent<VelocityApplier>().y = value.GetValue();
				}).WithDefaultValue(0f))
			});
			VelocityDamager = GroupUtils.Merge(Velocity, new List<Architect.Config.Types.ConfigType>(1) { DamagesEnemies });
			Bubble = GroupUtils.Merge(Gravity, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Pop Naturally", "bubble_pop", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					FSMUtility.LocateMyFSM(o, "Control").GetState("Idle").DisableAction(1);
				}
			}).WithDefaultValue(value: true)) });
			Watcher = GroupUtils.Merge(Wakeable, GroupUtils.Merge(Bosses, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Nook Y Offset", "watcher_nook_y", delegate(GameObject o, FloatConfigValue value)
			{
				FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmFloat("Cliff Y").value = Extensions.GetPositionY(o.transform) + value.GetValue();
			}).WithDefaultValue(1000f)) }));
			BurningBug = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Immolator", "burning_bug_explode", delegate(GameObject o, BoolConfigValue value)
			{
				PlayMakerFSM fsm4 = FSMUtility.LocateMyFSM(o, "Control");
				if (value.GetValue())
				{
					o.GetComponent<tk2dSpriteAnimator>().Play("Immolater Idle");
					HealthManager component10 = o.GetComponent<HealthManager>();
					component10.hasSpecialDeath = true;
					component10.enemyDeathEffects.doNotSpawnCorpse = true;
					fsm4.GetState("State").AddAction(delegate
					{
						fsm4.SendEvent("IMMOLATER");
					}, 3, everyFrame: false);
				}
				else
				{
					fsm4.GetState("Patrol Wait").AddAction(delegate
					{
						fsm4.SendEvent("WAKE");
					}, -1, everyFrame: false);
				}
			}).WithDefaultValue(value: false)) });
			HideBody = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Invisible Body", "surgeon_no_body", delegate(GameObject o, BoolConfigValue value)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				if (value.GetValue())
				{
					((tk2dBaseSprite)o.GetComponent<tk2dSprite>()).scale = Vector3.zero;
				}
			}).WithDefaultValue(value: false)) });
			Surgeon = GroupUtils.Merge(HideBody, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Dig Range", "surgeon_range", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<EnemyFixers.Teleplane>().width = value.GetValue();
			}).WithDefaultValue(5f)) });
			Clawmaiden = GroupUtils.Merge(HideBody, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Teleplane Width", "teleplane_width", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<EnemyFixers.Teleplane>().width = value.GetValue();
				}).WithDefaultValue(5f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Teleplane Height", "teleplane_height", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<EnemyFixers.Teleplane>().height = value.GetValue();
				}).WithDefaultValue(5f))
			});
			Jailer = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Captured Scene", "jailer_scene", delegate(GameObject o, StringConfigValue value)
				{
					o.GetOrAddComponent<EnemyFixers.CustomJailer>().targetScene = value.GetValue();
				}).WithDefaultValue("Slab_03").WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Captured Door ID", "jailer_door", delegate(GameObject o, StringConfigValue value)
				{
					o.GetOrAddComponent<EnemyFixers.CustomJailer>().targetDoor = value.GetValue();
				}).WithDefaultValue("door_slabCaged").WithPriority(-1))
			});
			Hoker = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Roam Around", "hoker_wander", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					PlayMakerFSM fsm3 = FSMUtility.LocateMyFSM(o, "Control");
					fsm3.GetState("Peaceful").DisableAction(0);
					fsm3.GetState("Idle").DisableAction(0);
					fsm3.GetState("Fire").DisableAction(5);
				}
			}).WithDefaultValue(value: true)) });
			Metronome = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Tick Time", "metronome_time", delegate(GameObject o, FloatConfigValue value)
				{
					MiscFixers.SetMetronomeTime(o, value.GetValue());
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Delay", "metronome_delay", delegate(GameObject o, FloatConfigValue value)
				{
					MiscFixers.SetMetronomeDelay(o, value.GetValue());
				}).WithDefaultValue(0f))
			});
			TextDisplay = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Text", "display_text", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<TextDisplay>().text = value.GetValue();
				}).WithDefaultValue("Sample Text").WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Vertical Alignment", "display_align_v", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<TextDisplay>().verticalAlignment = value.GetValue();
				}).WithOptions("Top", "Middle", "Bottom").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Horizontal Alignment", "display_align_h", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<TextDisplay>().horizontalAlignment = value.GetValue();
				}).WithOptions("Left", "Middle", "Right").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Textbox Y Offset", "display_y_offset", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<TextDisplay>().offsetY = value.GetValue();
				}).WithDefaultValue(0f).WithPriority(-1))
			});
			TitleDisplay = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Header", "title_header", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<TitleDisplay>().header = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Body", "title_body", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<TitleDisplay>().body = value.GetValue();
				}).WithDefaultValue("Sample Text")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Footer", "title_footer", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<TitleDisplay>().footer = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "title_type", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<TitleDisplay>().type = value.GetValue();
				}).WithOptions("Large", "Left", "Right").WithDefaultValue(0))
			});
			Choice = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(5)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Text", "choice_text", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<ChoiceDisplay>().text = value.GetValue();
				}).WithDefaultValue("Sample Text")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Requirement", "choice_currency", delegate(GameObject o, ChoiceConfigValue value)
				{
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					int value5 = value.GetValue();
					ChoiceDisplay component9 = o.GetComponent<ChoiceDisplay>();
					switch (value5)
					{
					case 0:
						component9.cost = 0;
						break;
					case 3:
						component9.useItem = true;
						break;
					}
					component9.currencyType = (CurrencyType)(value5 != 1);
				}).WithOptions("None", "Rosaries", "Shell Shards", "Item").WithDefaultValue(0).WithPriority(1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Required Amount", "choice_cost", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<ChoiceDisplay>().cost = value.GetValue();
				}).WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Item ID", "choice_item_id", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<ChoiceDisplay>().item = value.GetValue();
				}).WithDefaultValue("Simple Key")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Consume Item", "choice_take_item", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ChoiceDisplay>().takeItem = value.GetValue();
				}).WithDefaultValue(value: true))
			});
			PngUrl = Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("PNG URL", "png_url", delegate(GameObject o, StringConfigValue value)
			{
				o.GetComponentInChildren<PngObject>().url = value.GetValue();
			}, delegate(GameObject o, StringConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				PngPreview orAddComponent4 = o.GetOrAddComponent<PngPreview>();
				bool valueOrDefault = (orAddComponent4?.point).GetValueOrDefault(true);
				float valueOrDefault2 = (orAddComponent4?.ppu).GetValueOrDefault(100f);
				int valueOrDefault3 = (orAddComponent4?.vcount).GetValueOrDefault(1);
				int valueOrDefault4 = (orAddComponent4?.hcount).GetValueOrDefault(1);
				CustomAssetManager.DoLoadSprite(value.GetValue(), valueOrDefault, valueOrDefault2, valueOrDefault4, valueOrDefault3, delegate(Sprite[] sprites)
				{
					if (Object.op_Implicit((Object)(object)o))
					{
						o.GetComponent<SpriteRenderer>().sprite = sprites[0];
					}
					EditorUI.RefreshItem();
				});
			}).WithPriority(-1));
			Aa = Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Anti Aliasing", "png_antialias", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponentInChildren<PngObject>().point = !value.GetValue();
			}, delegate(GameObject o, BoolConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				o.GetOrAddComponent<PngPreview>().point = !value.GetValue();
			}).WithDefaultValue(value: true).WithPriority(-2));
			Png = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(9)
			{
				PngUrl,
				Aa,
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Pixels Per Unit", "png_ppu", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<PngObject>().ppu = value.GetValue();
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					o.GetOrAddComponent<PngPreview>().ppu = value.GetValue();
				}).WithDefaultValue(100f).WithPriority(-2)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new DoubleIntConfigType("Frame Counts", "png_allframecount", delegate(GameObject o, DoubleIntConfigValue value)
				{
					PngObject componentInChildren3 = o.GetComponentInChildren<PngObject>();
					(componentInChildren3.vcount, componentInChildren3.hcount) = value.GetValue();
				}, delegate(GameObject o, DoubleIntConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					PngPreview orAddComponent3 = o.GetOrAddComponent<PngPreview>();
					(orAddComponent3.vcount, orAddComponent3.hcount) = value.GetValue();
				}).WithDefaultValue((1, 1)).WithPriority(-2)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Empty Frame Count", "png_eframecount", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponentInChildren<PngObject>().dummy = value.GetValue();
				}).WithDefaultValue(0).WithPriority(-2)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Start Frame", "png_sframe", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponentInChildren<PngObject>().frame = Math.Max(0, value.GetValue());
				}).WithDefaultValue(0).WithPriority(-2)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Frames per Second", "png_frametime", delegate(GameObject o, FloatConfigValue value)
				{
					PngObject componentInChildren2 = o.GetComponentInChildren<PngObject>();
					if (value.GetValue() == 0f)
					{
						componentInChildren2.frameTime = 0f;
					}
					else
					{
						componentInChildren2.frameTime = 1f / Mathf.Max(0.01f, value.GetValue());
					}
				}).WithDefaultValue(10f).WithPriority(-2)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Loop", "png_loop", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponentInChildren<PngObject>().loop = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-2)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Play on Start", "png_start_playing", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponentInChildren<PngObject>().playing = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-2))
			});
			PhysicalPng = GroupUtils.Merge(Png, GroupUtils.Merge(StretchColourDecor, new List<Architect.Config.Types.ConfigType>()));
			SwaySpeed = Shader.PropertyToID("_SwaySpeed");
			SwayAmount = Shader.PropertyToID("_SwayAmount");
			SwayMultiplier = Shader.PropertyToID("_SwayMultiplier");
			Sway = GroupUtils.Merge(PhysicalPng, new List<Architect.Config.Types.ConfigType>(6)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Sway Speed", "sway_speed", delegate(GameObject o, FloatConfigValue value)
				{
					((Renderer)o.GetComponentInChildren<SpriteRenderer>()).material.SetFloat(SwaySpeed, value.GetValue());
				}).WithDefaultValue(0.4f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Sway Amount", "sway_amount", delegate(GameObject o, FloatConfigValue value)
				{
					((Renderer)o.GetComponentInChildren<SpriteRenderer>()).material.SetFloat(SwayAmount, value.GetValue());
				}).WithDefaultValue(0.018f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Sway Multiplier", "sway_multiplier", delegate(GameObject o, FloatConfigValue value)
				{
					((Renderer)o.GetComponentInChildren<SpriteRenderer>()).material.SetFloat(SwayMultiplier, value.GetValue());
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Disable Sway on Contact", "sway_hitbox", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.RemoveComponent<GrassBehaviour>();
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Collider Width", "sway_width", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_0010: 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)
					BoxCollider2D component8 = o.GetComponent<BoxCollider2D>();
					component8.size = new Vector2(value.GetValue(), component8.size.y);
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Collider Height", "sway_height", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_000a: 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)
					BoxCollider2D component7 = o.GetComponent<BoxCollider2D>();
					component7.size = new Vector2(component7.size.x, value.GetValue());
				}).WithDefaultValue(1f))
			});
			FullPng = GroupUtils.Merge(PhysicalPng, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Light Reflection", "png_glow", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponentInChildren<PngObject>().glow = value.GetValue();
			}).WithDefaultValue(value: false).WithPriority(-2)) });
			PngUI = GroupUtils.Merge(Png, new List<Architect.Config.Types.ConfigType>(4)
			{
				RenderLayer,
				Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Offset", "ui_png_offset", delegate(GameObject o, Vector2ConfigValue value)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: 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)
					UIPngObject orAddComponent2 = o.GetOrAddComponent<UIPngObject>();
					Vector2 value4 = value.GetValue();
					orAddComponent2.xOffset = value4.x;
					orAddComponent2.yOffset = value4.y;
				}).WithDefaultValue(Vector2.zero).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Shift With", "ui_png_anchor", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetOrAddComponent<UIPngObject>().anchorTo = value.GetValue();
				}).WithOptions("None", "LastMask", "LastTool").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Hide with HUD", "ui_png_hide_with_hud", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<UIPngObject>().ignoreHudOut = !value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1))
			});
			WavUrl = Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("WAV URL", "wav_url", delegate(GameObject o, StringConfigValue value)
			{
				o.GetComponentInChildren<WavObject>().url = value.GetValue();
			}).WithPriority(-1));
			Wav = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(7)
			{
				WavUrl,
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Volume", "wav_volume", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<WavObject>().Volume = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Pitch", "wav_pitch", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<WavObject>().pitch = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Sound Type", "wav_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<WavObject>().globalSound = value.GetValue() == 1;
				}).WithOptions("Local", "Global").WithDefaultValue(1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Volume Type", "wav_volume_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<WavObject>().soundType = value.GetValue();
				}).WithOptions("Master", "Music", "Sound").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Loop Sound", "wav_loop", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<WavObject>().loop = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Sync ID", "wav_sync_id", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<WavObject>().syncId = value.GetValue();
				}))
			});
			Mp4 = GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>(6)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("MP4 URL", "mp4_url", delegate(GameObject o, StringConfigValue value)
				{
					o.GetOrAddComponent<Mp4Object>().url = value.GetValue();
				}, delegate(GameObject o, StringConfigValue value, Architect.Config.ConfigurationManager.PreviewContext context)
				{
					VideoPlayer orAddComponent = o.GetOrAddComponent<VideoPlayer>();
					if (orAddComponent.playbackSpeed > 0f)
					{
						orAddComponent.playbackSpeed = 0f;
					}
					CustomAssetManager.DoLoadVideo(orAddComponent, (context == Architect.Config.ConfigurationManager.PreviewContext.Cursor) ? null : new float?(Extensions.GetScaleX(o.transform)), value.GetValue());
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Play on Start", "mp4_start_playing", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<Mp4Object>().playOnStart = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Loop Video", "mp4_loop", delegate(GameObject o, BoolConfigValue value)
				{
					if (value.GetValue())
					{
						o.GetComponent<VideoPlayer>().isLooping = value.GetValue();
					}
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Playback Speed", "mp4_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<VideoPlayer>().playbackSpeed = value.GetValue();
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Light Reflection", "mp4_glow", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponentInChildren<Mp4Object>().glow = value.GetValue();
				}).WithDefaultValue(value: false).WithPriority(-2)),
				AlphaColour
			});
			ActiveRegion = LayerMask.NameToLayer("ActiveRegion");
			SoftTerrain = LayerMask.NameToLayer("Soft Terrain");
			TriggerZones = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Trigger Type", "trigger_type", delegate(GameObject o, ChoiceConfigValue value)
				{
					int value3 = value.GetValue();
					o.GetComponent<TriggerZone>().mode = value3;
					if (value3 == 3)
					{
						o.layer = ActiveRegion;
						o.AddComponent<Rigidbody2D>().constraints = (RigidbodyConstraints2D)7;
					}
					else
					{
						o.layer = SoftTerrain;
					}
				}).WithOptions("Player", "Nail Swing", "Enemy", "Other Zone", "Activator").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Shape", "trigger_shape", delegate(GameObject o, ChoiceConfigValue value)
				{
					if (value.GetValue() != 0)
					{
						((Behaviour)o.GetComponent<PolygonCollider2D>()).enabled = true;
						((Behaviour)o.GetComponent<BoxCollider2D>()).enabled = false;
					}
				}, delegate(GameObject o, ChoiceConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					o.GetComponent<SpriteRenderer>().sprite = ((value.GetValue() == 0) ? TriggerZone.SquareZone : TriggerZone.CircleZone);
				}).WithOptions("Square", "Circle").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Trigger Layer", "trigger_layer", delegate(GameObject o, IntConfigValue value)
				{
					TriggerZone component6 = o.GetComponent<TriggerZone>();
					component6.layer = value.GetValue();
					component6.usingLayer = true;
				}).WithPriority(-1))
			});
			EnemyDamager = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Shape", "enemy_damager_shape", delegate(GameObject o, ChoiceConfigValue value)
				{
					if (value.GetValue() != 0)
					{
						((Behaviour)o.GetComponent<PolygonCollider2D>()).enabled = true;
						((Behaviour)o.GetComponent<BoxCollider2D>()).enabled = false;
					}
				}, delegate(GameObject o, ChoiceConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					o.GetComponent<SpriteRenderer>().sprite = ((value.GetValue() == 0) ? UtilityObjects.SquareDamager : UtilityObjects.CircleDamager);
				}).WithOptions("Square", "Circle").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Damage Type", "enemy_damager_damage_type", delegate(GameObject o, ChoiceConfigValue value)
				{
					//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_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_0058: Unknown result type (might be due to invalid IL or missing references)
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					//IL_004a: Unknown result type (might be due to invalid IL or missing references)
					//IL_004f: Unknown result type (might be due to invalid IL or missing references)
					string stringValue = value.GetStringValue();
					DamageEnemies component5 = o.GetComponent<DamageEnemies>();
					if (1 == 0)
					{
					}
					AttackTypes attackType2 = (AttackTypes)(stringValue switch
					{
						"Water" => 5, 
						"Zap" => 9, 
						"Needle" => 0, 
						_ => Enum.Parse<AttackTypes>(stringValue), 
					});
					if (1 == 0)
					{
					}
					component5.attackType = attackType2;
				}).WithDefaultValue(1).WithOptions("Generic", "Needle", "Spell", "Splatter", "Water", "Lava", "Explosion", "Coal", "Fire", "Zap", "Trap")),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Amount", "enemy_damager_hp_amount", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<DamageEnemies>().damageDealt = value.GetValue();
				}).WithDefaultValue(10)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Multi Hit", "enemy_damager_multihit", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<DamageEnemies>().multiHitter = value.GetValue();
				}).WithDefaultValue(value: false))
			});
			FleaCounter = GroupUtils.Merge(Png, new List<Architect.Config.Types.ConfigType>(7)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Start Score", "flea_counter_start", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().currentCount = value.GetValue();
				}).WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Bronze Score", "flea_counter_first", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().bronze = value.GetValue();
				}).WithDefaultValue(5).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Silver Score", "flea_counter_second", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().silver = value.GetValue();
				}).WithDefaultValue(10).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Gold Score", "flea_counter_third", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().gold = value.GetValue();
				}).WithDefaultValue(15).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "flea_counter_mode", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().high = value.GetValue() == 0;
				}).WithOptions("Highest", "Lowest").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Title Header", "flea_counter_header", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().header = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Title Footer", "flea_counter_footer", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().footer = value.GetValue();
				}).WithPriority(-1))
			});
			Interaction = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Label", "interaction_label", delegate(GameObject o, ChoiceConfigValue value)
				{
					//IL_0023: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					if (Enum.TryParse<PromptLabels>(CustomInteraction.Labels[value.GetValue()], out PromptLabels result2))
					{
						((InteractableBase)o.GetComponent<CustomInteraction>()).interactLabel = result2;
					}
				}).WithOptions(CustomInteraction.Labels).WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Hide on Interact", "interaction_hide", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<CustomInteraction>().hideOnInteract = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Offset", "interaction_offset", delegate(GameObject o, Vector2ConfigValue value)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: 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)
					CustomInteraction component4 = o.GetComponent<CustomInteraction>();
					Vector2 value2 = value.GetValue();
					component4.xOffset = value2.x;
					component4.yOffset = value2.y;
				}).WithDefaultValue(Vector2.zero))
			});
			RosaryBead = GroupUtils.Merge(Gravity, GroupUtils.Merge(Png, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Rosary Worth", "bead_worth", delegate(GameObject o, IntConfigValue value)
				{
					GeoControl component3 = o.GetComponent<GeoControl>();
					if (Object.op_Implicit((Object)(object)component3))
					{
						CostReference val3 = ScriptableObject.CreateInstance<CostReference>();
						((IntReference)val3).value = value.GetValue();
						component3.valueReference = val3;
					}
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Delete after Time", "delete_after_time", delegate(GameObject o, FloatConfigValue value)
				{
					o.AddComponent<DeleteAfterTime>().value = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Collectable", "bead_collectable", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.RemoveComponent<EventRegister>();
						o.RemoveComponent<GeoControl>();
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(MakePersistenceConfigType("Stay Collected", "rosary_stay").WithDefaultValue(0))
			}));
			HazardRespawn = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Collision Trigger", "hrp_collision", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.RemoveComponent<Collider2D>();
					}
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Collision Width", "hrp_width", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_0015: 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)
					if (!EditManager.IsEditing)
					{
						BoxCollider2D component2 = o.GetComponent<BoxCollider2D>();
						component2.size = Extensions.Where(component2.size, (float?)value.GetValue(), (float?)null);
					}
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					Extensions.SetScaleX(o.transform, value.GetValue());
				}).WithDefaultValue(1f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Collision Height", "hrp_height", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_0015: 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)
					if (!EditManager.IsEditing)
					{
						BoxCollider2D component = o.GetComponent<BoxCollider2D>();
						Vector2 size = component.size;
						float? num = value.GetValue();
						component.size = Extensions.Where(size, (float?)null, num);
					}
				}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
				{
					Extensions.SetScaleY(o.transform, value.GetValue());
				}).WithDefaultValue(1f))
			});
			ReflectionOffset = Shader.PropertyToID("_ReflectionOffset");
			Mirror = GroupUtils.Merge(Stretchable, GroupUtils.Merge(PhysicalPng, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Alpha Colour", "mirror_alpha", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_0022: Unknown result type (might be due to invalid IL or missing references)
					o.GetComponent<SpriteRenderer>().color = new Color(1f, 1f, 1f, value.GetValue() * 1.75f);
				}).WithDefaultValue(0.75f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Reflection Offset", "mirror_offset", delegate(GameObject o, FloatConfigValue value)
				{
					Material material2 = ((Renderer)o.GetComponent<SpriteRenderer>()).material;
					material2.SetFloat(ReflectionOffset, value.GetValue());
				}).WithDefaultValue(-4.1f))
			}));
			Speed = Shader.PropertyToID("_Speed");
			FlowingWater = GroupUtils.Merge(Stretchable, GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Speed", "water_effect_speed", delegate(GameObject o, FloatConfigValue value)
			{
				MeshRenderer[] componentsInChildren = o.GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer val2 in componentsInChildren)
				{
					Material material = ((Renderer)val2).material;
					material.SetFloat(Speed, material.GetFloat(Speed) * value.GetValue());
				}
			}).WithDefaultValue(1f)) }));
			PoleRing = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Height", "ring_height", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				Transform transform = o.transform;
				transform.position -= o.transform.rotation * new Vector3(value.GetValue(), 0f);
				o.transform.GetChild(0).GetChild(0).Translate(0f, value.GetValue(), 0f);
			}).WithDefaultValue(5f).WithPriority(-1)) });
			MapperRing = GroupUtils.Merge(TriggerActivator, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Fall Over", "ring_fall", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.RemoveComponent<CogRollThenFallOver>();
					}
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Velocity", "ring_x_vel", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.MapperRing>().x = value.GetValue();
				}).WithDefaultValue(0f).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Velocity", "ring_y_vel", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.MapperRing>().y = value.GetValue();
				}).WithDefaultValue(0f).WithPriority(-1))
			});
			Transitions = GroupUtils.Merge(Stretchable, new List<Architect.Config.Types.ConfigType>(7)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Gate Type", "trans_type", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<CustomTransitionPoint>().pointType = value.GetValue();
				}).WithOptions("Door", "Left", "Right", "Top", "Bottom", "Wake").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Door ID", "trans_id", delegate(GameObject o, StringConfigValue value)
				{
					((Object)o).name = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Target Door ID", "trans_other_id", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<TransitionPoint>().entryPoint = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Target Scene", "trans_other_scene", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<TransitionPoint>().targetScene = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Entry Delay", "trans_delay", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<TransitionPoint>().entryDelay = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Trigger Type", "trans_collide", delegate(GameObject o, ChoiceConfigValue value)
				{
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					o.GetComponent<TransitionPoint>().isADoor = value.GetValue() == 1;
					if (value.GetValue() == 2)
					{
						((Collider2D)o.GetComponent<BoxCollider2D>()).offset = new Vector2(-9999f, -9999f);
					}
				}).WithOptions("Collision", "Door", "None").WithDefaultValue(0).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Active in Editor", "trans_edit_mode_active", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<CustomTransitionPoint>().applyInEditMode = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1))
			});
			BindSource = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(4)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Target Scene", "bind_source_scene", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<InteractableFixers.BindSource>().sceneId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Target Door ID", "bind_source_door", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<InteractableFixers.BindSource>().doorId = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Bind Count", "bind_source_count", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<InteractableFixers.BindSource>().bindCount = value.GetValue();
				}).WithDefaultValue(3)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Interactable", "bind_source_can_interact", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						((Behaviour)o.GetComponent<PlayMakerNPC>()).enabled = false;
					}
				}).WithDefaultValue(value: true))
			});
			Skarrwing = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start on Ceiling", "buzzer_ceiling", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(o, "Control");
					fsm2.GetState("Initiate").AddAction(delegate
					{
						fsm2.FsmVariables.FindFsmBool("Start Alert").Value = true;
					}, 0, everyFrame: false);
				}
			}).WithDefaultValue(value: false)) });
			SpearSkarr = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Awake", "spear_awake", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					o.GetComponent<EnemyFixers.Wakeable>().DoWake();
				}
			}).WithDefaultValue(value: true)) });
			Judge = GroupUtils.Merge(Enemies, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Awake", "judge_awake", delegate(GameObject o, BoolConfigValue value)
			{
				if (value.GetValue())
				{
					o.GetComponent<EnemyFixers.Wakeable>().DoWake();
				}
			}).WithDefaultValue(value: true)) });
			Bindings = GroupUtils.Merge(Mutable, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Binding Active", "binding_active", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Binding>().active = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Reversible", "binding_toggle", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Binding>().reversible = value.GetValue();
				}).WithDefaultValue(value: false)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Appear in UI", "binding_ui", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<Binding>().uiVisible = value.GetValue();
				}).WithDefaultValue(value: true))
			});
			KeyListener = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Keybind", "key_listener_key", delegate(GameObject o, StringConfigValue value)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				if (Enum.TryParse<KeyCode>(value.GetValue(), ignoreCase: true, out KeyCode result))
				{
					o.GetComponent<KeyListener>().key = result;
				}
			})) });
			Bumpers = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Mode", "bumper_mode", delegate(GameObject o, ChoiceConfigValue value)
			{
				o.GetComponent<Bumper>().SetEvil(value.GetValue() == 1);
			}, delegate(GameObject o, ChoiceConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				o.GetComponent<SpriteRenderer>().sprite = ((value.GetValue() == 0) ? Bumper.NormalIcon : Bumper.EvilIcon);
			}).WithOptions("Regular", "Fire").WithDefaultValue(0)) });
			Remover = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Filter", "remover_filter", delegate(GameObject o, StringConfigValue value)
			{
				o.GetComponent<ObjectRemover>().filter = value.GetValue();
			})) });
			DisableRenderer = GroupUtils.Merge(Remover, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Disable All In Range", "remover_all_in_range", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<ObjectRemover>().allInRange = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Range", "remover_range", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<ObjectRemover>().range = value.GetValue();
				}).WithDefaultValue(25f))
			});
			RoomClearer = GroupUtils.Merge(Remover, new List<Architect.Config.Types.ConfigType>(6)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Remove Transitions", "remove_transitions", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<RoomClearerConfig>().removeTransitions = value.GetValue();
				}).WithDefaultValue(value: false).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Remove Benches", "remove_benches", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<RoomClearerConfig>().removeBenches = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Remove Blur", "remove_blur", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<RoomClearerConfig>().removeBlur = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Remove Music", "remove_music", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<RoomClearerConfig>().removeMusic = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Remove Tilemap", "remove_tilemap", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<RoomClearerConfig>().removeTilemap = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Remove Other", "remove_other", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetOrAddComponent<RoomClearerConfig>().removeOther = value.GetValue();
				}).WithDefaultValue(value: true).WithPriority(-1))
			});
			ObjectRemover = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Path", "remover_path", delegate(GameObject o, StringConfigValue value)
				{
					o.GetOrAddComponent<ObjectRemoverConfig>().objectPath = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Index", "remover_index", delegate(GameObject o, IntConfigValue value)
				{
					o.GetOrAddComponent<ObjectRemoverConfig>().index = value.GetValue();
				}).WithDefaultValue(0).WithPriority(-1))
			});
			ObjectEnabler = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType("Path", "enabler_path", delegate(GameObject o, StringConfigValue value)
				{
					o.GetComponent<ObjectEnabler>().objectPath = value.GetValue();
				}).WithPriority(-1)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Index", "enabler_index", delegate(GameObject o, IntConfigValue value)
				{
					o.GetComponent<ObjectEnabler>().index = value.GetValue();
				}).WithDefaultValue(0).WithPriority(-1))
			});
			PlayerHazards = GroupUtils.Merge(Decorations, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Damages Player", "damages_player", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					o.RemoveComponentsInChildren<DamageHero>();
					o.RemoveComponentsInChildren<CogMultiHitter>();
					Transform val = o.transform.Find("damager");
					if (Object.op_Implicit((Object)(object)val))
					{
						((Component)val).gameObject.RemoveComponent<PlayMakerFSM>();
					}
				}
			})) });
			Hazards = GroupUtils.Merge(PlayerHazards, new List<Architect.Config.Types.ConfigType>(1) { DamagesEnemies });
			StretchableHazards = GroupUtils.Merge(Stretchable, GroupUtils.Merge(Hazards, new List<Architect.Config.Types.ConfigType>()));
			WhiteSpikes = GroupUtils.Merge(Mutable, GroupUtils.Merge(Hazards, new List<Architect.Config.Types.ConfigType>(3)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Up", "wp_spikes_up", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponentInChildren<WhiteSpikes>().up = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Delay", "wp_spikes_delay", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<WhiteSpikes>().shiftDelay = value.GetValue();
				}).WithDefaultValue(0f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Speed", "wp_spikes_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponentInChildren<WhiteSpikes>().speed = value.GetValue();
				}).WithDefaultValue(1f))
			}));
			Cogs = GroupUtils.Merge(Hazards, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Rotation Speed", "cog_rot_speed", delegate(GameObject o, FloatConfigValue value)
			{
				((VectorCurveAnimator)o.GetComponentInChildren<CurveRotationAnimation>()).OffsetZ = value.GetValue();
			})) });
			Binoculars = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(5)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Camera Speed", "freecam_speed", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Binoculars>().speed = value.GetValue() * 10f;
				}).WithDefaultValue(2f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Zoom", "freecam_start_zoom", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Binoculars>().startZoom = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Zoom Minimum", "freecam_min_zoom", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Binoculars>().minZoom = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Zoom Maximum", "freecam_max_zoom", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<Binoculars>().maxZoom = value.GetValue();
				})),
				Architect.Config.ConfigurationManager.RegisterConfigType(new Vector2ConfigType("Start Offset", "freecam_offset", delegate(GameObject o, Vector2ConfigValue value)
				{
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					o.GetComponent<Binoculars>().startOffset = Vector2.op_Implicit(value.GetValue());
				}))
			});
			CloverPod = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Start Grown", "start_grown", delegate(GameObject o, BoolConfigValue value)
			{
				o.GetComponent<ActivatingBase>().startActive = value.GetValue();
			}).WithDefaultValue(value: false)) });
			BellPod = GroupUtils.Merge(CloverPod, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Pitch", "bell_pod_pitch", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: 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)
				BouncePod componentInChildren = o.GetComponentInChildren<BouncePod>(true);
				AudioEventRandom bounceSounds = componentInChildren.bounceSounds;
				bounceSounds.PitchMin = value.GetValue();
				bounceSounds.PitchMax = value.GetValue();
				componentInChildren.bounceSounds = bounceSounds;
			}).WithDefaultValue(1f)) });
			FallingBell = GroupUtils.Merge(Hazards, new List<Architect.Config.Types.ConfigType>(1) { Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Reset Time", "bell_reset", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				((Wait)FSMUtility.LocateMyFSM(o, "Control").GetState("Reset Pause").actions[0]).time = FsmFloat.op_Implicit(value.GetValue());
			}).WithDefaultValue(1f)) });
			GrindPlat = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Fall Distance", "grind_plat_dist", delegate(GameObject o, FloatConfigValue value)
				{
					FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmFloat("Drop Y").Value = Extensions.GetPositionY(o.transform) - value.GetValue();
				}).WithDefaultValue(5f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Stay Time", "grind_plat_time", delegate(GameObject o, FloatConfigValue value)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					((Wait)FSMUtility.LocateMyFSM(o, "Control").GetState("Land Grind").actions[4]).time = FsmFloat.op_Implicit(value.GetValue());
				}).WithDefaultValue(1.5f))
			});
			BlackStrand = GroupUtils.Merge(Generic, new List<Architect.Config.Types.ConfigType>(2)
			{
				ZOffset,
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Require Act 3", "require_act_3_blackstrand", delegate(GameObject o, BoolConfigValue value)
				{
					if (!value.GetValue())
					{
						o.RemoveComponent<DeactivateIfPlayerdataFalse>();
					}
				}).WithDefaultValue(value: false).WithPriority(-1))
			});
			BounceFlea = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(5)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Direction", "bounce_flea_dir", delegate(GameObject o, ChoiceConfigValue value)
				{
					if (value.GetValue() != 0)
					{
						o.GetComponent<MiscFixers.BounceFlea>().isRight = true;
					}
				}).WithOptions("Left", "Right").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Fly Away on Hit", "bounce_flea_leave", delegate(GameObject o, BoolConfigValue value)
				{
					o.GetComponent<MiscFixers.BounceFlea>().flyAway = value.GetValue();
				}).WithDefaultValue(value: true)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Distance", "bounce_flea_dist", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.BounceFlea>().distance = value.GetValue();
				}).WithDefaultValue(10f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Wave Top Offset", "bounce_flea_wave_top", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.BounceFlea>().topYOffset = value.GetValue();
				}).WithDefaultValue(2f)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Wave Bottom Offset", "bounce_flea_wave_bot", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.BounceFlea>().botYOffset = value.GetValue();
				}).WithDefaultValue(-2f))
			});
			DodgeFlea = GroupUtils.Merge(Visible, new List<Architect.Config.Types.ConfigType>(2)
			{
				Architect.Config.ConfigurationManager.RegisterConfigType(new ChoiceConfigType("Direction", "dodge_flea_dir", delegate(GameObject o, ChoiceConfigValue value)
				{
					o.GetComponent<MiscFixers.DodgeFlea>().dir = value.GetValue();
				}).WithOptions("Left", "Right", "DiagLeft", "DiagRight", "Down").WithDefaultValue(0)),
				Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Max Flight Distance", "dodge_flea_max_dist", delegate(GameObject o, FloatConfigValue value)
				{
					o.GetComponent<MiscFixers.DodgeFlea>().dist = value.GetValue();
				}).WithDefaultValue(50f))
			});
			typeof(HealthManager).Hook("IsBlockingByDirection", (Func<Func<HealthManager, int, AttackTypes, SpecialTypes, bool>, HealthManager, int, AttackTypes, SpecialTypes, bool>)((Func<HealthManager, int, AttackTypes, SpecialTypes, bool> orig, HealthManager self, int cardinalDirection, AttackTypes attackType, SpecialTypes specialType) => Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<EnemyInvulnerabilityMarker>()) || orig(self, cardinalDirection, attackType, specialType)));
			new Hook((MethodBase)typeof(HealthManager).GetProperty("IsInvincible").GetGetMethod(), (Delegate)(Func<Func<HealthManager, bool>, HealthManager, bool>)((Func<HealthManager, bool> orig, HealthManager self) => Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<EnemyInvulnerabilityMarker>()) || orig(self)));
			new Hook((MethodBase)typeof(HealthManager).GetProperty("WillAwardJournalKill").GetGetMethod(), (Delegate)(Func<Func<HealthManager, bool>, HealthManager, bool>)((Func<HealthManager, bool> orig, HealthManager self) => !Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<JournalKillDisablerMarker>()) && orig(self)));
		}

		private static ChoiceConfigType MakePersistenceConfigType(string name, string id, Action<GameObject, PersistentBoolItem> action = null)
		{
			ChoiceConfigType choiceConfigType = new ChoiceConfigType(name, id, delegate(GameObject o, ChoiceConfigValue value)
			{
				//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_0078: Expected O, but got Unknown
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				//IL_0092: Expected O, but got Unknown
				int value2 = value.GetValue();
				if (value2 == 0)
				{
					o.RemoveComponentsInChildren<PersistentBoolItem>();
					o.RemoveComponentsInChildren<PersistentIntItem>();
				}
				else
				{
					PersistentBoolItem componentInChildren = o.GetComponentInChildren<PersistentBoolItem>();
					PersistentIntItem componentInChildren2 = o.GetComponentInChildren<PersistentIntItem>();
					EnemyFixers.FakePersistentMarker component = o.GetComponent<EnemyFixers.FakePersistentMarker>();
					if ((!Object.op_Implicit((Object)(object)componentInChildren) && !Object.op_Implicit((Object)(object)componentInChildren2)) || Object.op_Implicit((Object)(object)component))
					{
						PersistentBoolItem orAddComponent = o.GetOrAddComponent<PersistentBoolItem>();
						PersistentBoolData val = new PersistentBoolData();
						((PersistentItemData<bool>)val).ID = ((Object)o).name;
						Scene scene = o.scene;
						((PersistentItemData<bool>)val).SceneName = ((Scene)(ref scene)).name;
						orAddComponent.itemData = val;
						action?.Invoke(o, orAddComponent);
					}
					o.AddComponent<SemiPersistentBool>().semiPersistent = value2 == 1;
				}
			}).WithOptions("False", "Bench", "True");
			choiceConfigType.WithPriority(-1);
			return choiceConfigType;
		}

		public static void Init()
		{
			Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Vertical Frame Count", "png_framecount", delegate(GameObject o, IntConfigValue value)
			{
				o.GetComponentInChildren<PngObject>().vcount = value.GetValue();
			}, delegate(GameObject o, IntConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				o.GetOrAddComponent<PngPreview>().vcount = value.GetValue();
			}).WithDefaultValue(1).WithPriority(-2));
			Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Horizontal Frame Count", "png_hframecount", delegate(GameObject o, IntConfigValue value)
			{
				o.GetComponentInChildren<PngObject>().hcount = value.GetValue();
			}, delegate(GameObject o, IntConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				o.GetOrAddComponent<PngPreview>().hcount = value.GetValue();
			}).WithDefaultValue(1).WithPriority(-2));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Offset X", "freecam_offset_x", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<Binoculars>().startOffset.x = value.GetValue();
			}));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Start Offset Y", "freecam_offset_y", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<Binoculars>().startOffset.y = value.GetValue();
			}));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Sit Offset X", "bench_offset_x", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				FsmVector3 val5 = o.GetComponentsInChildren<PlayMakerFSM>().First((PlayMakerFSM fsm) => fsm.FsmName == "Bench Control").FsmVariables.FindFsmVector3("Adjust Vector");
				val5.Value += new Vector3(value.GetValue(), 0f, 0f);
			}).WithDefaultValue(0f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Sit Offset Y", "bench_offset_y", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				FsmVector3 val4 = o.GetComponentsInChildren<PlayMakerFSM>().First((PlayMakerFSM fsm) => fsm.FsmName == "Bench Control").FsmVariables.FindFsmVector3("Adjust Vector");
				val4.Value += new Vector3(0f, value.GetValue(), 0f);
			}).WithDefaultValue(0f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Sit Offset Z", "bench_offset_z", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				FsmVector3 val3 = o.GetComponentsInChildren<PlayMakerFSM>().First((PlayMakerFSM fsm) => fsm.FsmName == "Bench Control").FsmVariables.FindFsmVector3("Adjust Vector");
				val3.Value += new Vector3(0f, 0f, value.GetValue());
			}).WithDefaultValue(0f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Offset", "mover_x_offset", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<ObjectMover>().xOffset = value.GetValue();
			}).WithDefaultValue(0f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Offset", "mover_y_offset", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<ObjectMover>().yOffset = value.GetValue();
			}).WithDefaultValue(0f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("UI X Offset", "ui_camera_target_x", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetOrAddComponent<CameraObjects.CustomCameraTarget>().xOffset = value.GetValue();
			}).WithDefaultValue(0f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("UI Y Offset", "ui_camera_target_y", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetOrAddComponent<CameraObjects.CustomCameraTarget>().yOffset = value.GetValue();
			}).WithDefaultValue(0f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Offset", "interaction_offset_x", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<CustomInteraction>().xOffset = value.GetValue();
			}).WithDefaultValue(0f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Offset", "interaction_offset_y", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<CustomInteraction>().yOffset = value.GetValue();
			}).WithDefaultValue(2.5f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("X Offset", "ui_png_x", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetOrAddComponent<UIPngObject>().xOffset = value.GetValue();
			}).WithDefaultValue(0f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Y Offset", "ui_png_y", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetOrAddComponent<UIPngObject>().yOffset = value.GetValue();
			}).WithDefaultValue(0f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Target X Offset", "patroller_x", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<EnemyFixers.PatrollerFix>().xOffset = value.GetValue();
			}).WithDefaultValue(5f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Target X Offset", "winged_furm_x", delegate(GameObject o, FloatConfigValue value)
			{
				//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_003d: Unknown result type (might be due to invalid IL or missing references)
				FsmVector3 val2 = FSMUtility.LocateMyFSM(o, "Tween").FsmVariables.FindFsmVector3("Move Pos");
				Vector3 value3 = val2.Value;
				value3.x = Extensions.GetPositionX(o.transform) + value.GetValue();
				val2.Value = value3;
			}).WithDefaultValue(0f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Target Y Offset", "winged_furm_y", delegate(GameObject o, FloatConfigValue value)
			{
				//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_003d: Unknown result type (might be due to invalid IL or missing references)
				FsmVector3 val = FSMUtility.LocateMyFSM(o, "Tween").FsmVariables.FindFsmVector3("Move Pos");
				Vector3 value2 = val.Value;
				value2.y = Extensions.GetPositionY(o.transform) + value.GetValue();
				val.Value = value2;
			}).WithDefaultValue(5f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Width", "size_width", delegate(GameObject o, FloatConfigValue value)
			{
				Extensions.SetScaleX(o.transform, Extensions.GetScaleX(o.transform) * value.GetValue());
			}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				Extensions.SetScaleX(o.transform, Extensions.GetScaleX(o.transform) * value.GetValue());
			}));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Height", "size_height", delegate(GameObject o, FloatConfigValue value)
			{
				Extensions.SetScaleY(o.transform, Extensions.GetScaleY(o.transform) * value.GetValue());
			}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				Extensions.SetScaleY(o.transform, Extensions.GetScaleY(o.transform) * value.GetValue());
			}));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Height", "heat_height", delegate(GameObject o, FloatConfigValue value)
			{
				Extensions.SetScaleZ(o.transform, Extensions.GetScaleZ(o.transform) * value.GetValue());
			}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext _)
			{
				Extensions.SetScaleY(o.transform, Extensions.GetScaleY(o.transform) * value.GetValue());
			}));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour R", "colour_red", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer component6 = o.GetComponent<SpriteRenderer>();
				Color color10 = component6.color;
				color10.r = value.GetValue();
				component6.color = color10;
			}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (arg3 != 0)
				{
					SpriteRenderer component5 = o.GetComponent<SpriteRenderer>();
					Color color9 = component5.color;
					color9.r = value.GetValue();
					component5.color = color9;
				}
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour G", "colour_green", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer component4 = o.GetComponent<SpriteRenderer>();
				Color color8 = component4.color;
				color8.g = value.GetValue();
				component4.color = color8;
			}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (arg3 != 0)
				{
					SpriteRenderer component3 = o.GetComponent<SpriteRenderer>();
					Color color7 = component3.color;
					color7.g = value.GetValue();
					component3.color = color7;
				}
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour B", "colour_blue", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer component2 = o.GetComponent<SpriteRenderer>();
				Color color6 = component2.color;
				color6.b = value.GetValue();
				component2.color = color6;
			}, delegate(GameObject o, FloatConfigValue value, Architect.Config.ConfigurationManager.PreviewContext arg3)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (arg3 != 0)
				{
					SpriteRenderer component = o.GetComponent<SpriteRenderer>();
					Color color5 = component.color;
					color5.b = value.GetValue();
					component.color = color5;
				}
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour R", "line_red", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<LineObject>().r = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour G", "line_green", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<LineObject>().g = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour B", "line_blue", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<LineObject>().b = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour A", "line_alpha", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<LineObject>().a = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour R", "track_r", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<SplineObjects.Spline>().r = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour G", "track_g", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<SplineObjects.Spline>().g = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour B", "track_b", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<SplineObjects.Spline>().b = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour A", "track_a", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<SplineObjects.Spline>().a = value.GetValue();
			}).WithDefaultValue(0.1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour R", "png_col_r", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer componentInChildren4 = o.GetComponentInChildren<SpriteRenderer>();
				Color color4 = componentInChildren4.color;
				color4.r = value.GetValue();
				componentInChildren4.color = color4;
			}).WithDefaultValue(1f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour G", "png_col_g", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer componentInChildren3 = o.GetComponentInChildren<SpriteRenderer>();
				Color color3 = componentInChildren3.color;
				color3.g = value.GetValue();
				componentInChildren3.color = color3;
			}).WithDefaultValue(1f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour B", "png_col_b", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer componentInChildren2 = o.GetComponentInChildren<SpriteRenderer>();
				Color color2 = componentInChildren2.color;
				color2.b = value.GetValue();
				componentInChildren2.color = color2;
			}).WithDefaultValue(1f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour A", "png_col_a", delegate(GameObject o, FloatConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				SpriteRenderer componentInChildren = o.GetComponentInChildren<SpriteRenderer>();
				Color color = componentInChildren.color;
				color.a = value.GetValue();
				componentInChildren.color = color;
			}).WithDefaultValue(1f).WithPriority(-1));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour R", "colourer_red", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<ObjectColourer>().r = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour G", "colourer_green", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<ObjectColourer>().g = value.GetValue();
			}).WithDefaultValue(1f));
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Colour B", "colourer_blue", delegate(GameObject o, FloatConfigValue value)
			{
				o.GetComponent<ObjectColourer>().b = value.GetValue();
			}).WithDefaultValue(1f));
		}
	}
	public static class GroupUtils
	{
		public static List<T> Merge<T>(List<T> first, List<T> second)
		{
			foreach (T item in first)
			{
				if (second.Contains(item))
				{
					second.Remove(item);
				}
				second.Add(item);
			}
			return second;
		}
	}
	public static class InputGroup
	{
		public static readonly List<(string, string)> Generic = new List<(string, string)>();

		public static readonly List<(string, string)> Wav = new List<(string, string)>(1) { ("New Volume", "Number") };

		public static readonly List<(string, string)> ObjectMover = new List<(string, string)>(3)
		{
			("Extra X", "Number"),
			("Extra Y", "Number"),
			("Extra Rot", "Number")
		};

		public static readonly List<(string, string)> Velocity = new List<(string, string)>(2)
		{
			("New X", "Number"),
			("New Y", "Number")
		};

		public static readonly List<(string, string)> FleaCounter = new List<(string, string)>(1) { ("New Value", "Number") };

		public static readonly List<(string, string)> FsmHook = new List<(string, string)>(1) { ("Event", "Text") };

		public static readonly List<(string, string)> EnemyDamager = new List<(string, string)>(1) { ("New Damage", "Number") };

		public static readonly List<(string, string)> ComponentHook = new List<(string, string)>(1) { ("New Value", "Any") };

		public static readonly List<(string, string)> EnemyHook = new List<(string, string)>(1) { ("New Enemy", "Enemy") };

		public static readonly List<(string, string)> Particles = new List<(string, string)>(1) { ("Count", "Number") };

		public static readonly List<(string, string)> BounceFlea = new List<(string, string)>(3)
		{
			("Fly Y", "Number"),
			("Speed", "Number"),
			("Quick", "Boolean")
		};

		public static readonly List<(string, string)> Ventrica = new List<(string, string)>(2)
		{
			("To Door", "Text"),
			("To Scene", "Text")
		};

		public static readonly List<(string, string)> DodgeFlea = new List<(string, string)>(2)
		{
			("Speed", "Number"),
			("Quick", "Boolean")
		};

		public static readonly List<(string, string)> Png = new List<(string, string)>(7)
		{
			("New Frame", "Number"),
			ScriptBlock.Space,
			("New Width", "Number"),
			ScriptBlock.Space,
			("New Height", "Number"),
			ScriptBlock.Space,
			("New FPS", "Number")
		};

		public static readonly List<(string, string)> Colourer = new List<(string, string)>(5)
		{
			("R", "Number"),
			("G", "Number"),
			("B", "Number"),
			("A", "Number"),
			("Fade Time", "Number")
		};
	}
	public static class OutputGroup
	{
		private static readonly OutputType Space = new OutputType("space", "", "", null);

		public static readonly List<OutputType> Generic = new List<OutputType>();

		public static readonly List<OutputType> Objects = new List<OutputType>(1) { EventManager.RegisterOutputType(new OutputType("object_self", "Self", "Object", (GameObject o) => o)) };

		public static readonly List<OutputType> Enemies = new List<OutputType>(2)
		{
			EventManager.RegisterOutputType(new OutputType("hp", "Health", "Number", delegate(GameObject o)
			{
				HealthManager componentInChildren = o.GetComponentInChildren<HealthManager>();
				return Object.op_Implicit((Object)(object)componentInChildren) ? componentInChildren.hp : 0;
			})),
			EventManager.RegisterOutputType(new OutputType("enemy_self", "Self", "Enemy", (GameObject o) => o.GetComponentInChildren<HealthManager>()))
		};

		public static readonly List<OutputType> EnemyDamager = GroupUtils.Merge(Objects, new List<OutputType>(1) { EventManager.RegisterOutputType(new OutputType("enemy_lastdmg", "LastDamaged", "Enemy", delegate(GameObject o)
		{
			UtilityObjects.EnemyDamager component = o.GetComponent<UtilityObjects.EnemyDamager>();
			return component.last;
		})) });

		public static readonly List<OutputType> EnemyHook = new List<OutputType>(2)
		{
			EventManager.RegisterOutputType(new OutputType("hp_hook", "Health", "Number", delegate(GameObject o)
			{
				HealthManager hm = o.GetComponent<EnemyHook>().hm;
				return Object.op_Implicit((Object)(object)hm) ? hm.hp : 0;
			})),
			EventManager.RegisterOutputType(new OutputType("hp_hook_target", "Target", "Enemy", (GameObject o) => o.GetComponent<EnemyHook>().hm))
		};

		public static readonly List<OutputType> ObjectHook = new List<OutputType>(1) { EventManager.RegisterOutputType(new OutputType("obj_hook_target", "Target", "Object", (GameObject o) => o.GetComponent<ObjectHook>().o)) };

		public static readonly List<OutputType> TriggerZone = GroupUtils.Merge(Objects, new List<OutputType>(1) { EventManager.RegisterOutputType(new OutputType("trigger_inside", "Inside", "Boolean", (GameObject o) => o.GetComponent<TriggerZone>().inside)) });

		public static readonly List<OutputType> FleaCounter = GroupUtils.Merge(Objects, new List<OutputType>(1) { EventManager.RegisterOutputType(new OutputType("flea_score", "Score", "Number", (GameObject o) => o.GetComponent<MiscFixers.CustomFleaCounter>().currentCount)) });

		public static readonly List<OutputType> Png = GroupUtils.Merge(Objects, new List<OutputType>(3)
		{
			EventManager.RegisterOutputType(new OutputType("png_sprite", "Current Sprite", "Sprite", (GameObject o) => o.GetComponent<SpriteRenderer>().sprite)),
			Space,
			EventManager.RegisterOutputType(new OutputType("png_frame", "Frame", "Number", (GameObject o) => o.GetComponent<PngObject>().frame))
		});

		public static readonly List<OutputType> FsmHook = GroupUtils.Merge(Objects, new List<OutputType>(2)
		{
			EventManager.RegisterOutputType(new OutputType("fsm_hoo_state", "State", "Text", (GameObject o) => o.GetComponent<FsmHook>().GetState())),
			EventManager.RegisterOutputType(new OutputType("fsm_hook_time", "Time", "Number", (GameObject o) => o.GetComponent<FsmHook>().GetTime()))
		});

		public static readonly List<OutputType> ObjectAnchor = GroupUtils.Merge(Objects, new List<OutputType>(2)
		{
			EventManager.RegisterOutputType(new OutputType("anchor_x", "X", "Number", (GameObject o) => Extensions.GetPositionX(o.transform))),
			EventManager.RegisterOutputType(new OutputType("anchor_y", "Y", "Number", (GameObject o) => Extensions.GetPositionY(o.transform)))
		});

		public static readonly List<OutputType> LastJudge = GroupUtils.Merge(Enemies, new List<OutputType>(2)
		{
			EventManager.RegisterOutputType(new OutputType("censer_x", "Censer X", "Number", delegate(GameObject o)
			{
				PlayMakerFSM val3 = FSMUtility.LocateMyFSM(o, "Control");
				FsmGameObject val4 = val3.FsmVariables.FindFsmGameObject("Censer Throw");
				return Object.op_Implicit((Object)(object)val4.value) ? Extensions.GetPositionX(val4.value.transform) : 0f;
			})),
			EventManager.RegisterOutputType(new OutputType("censer_y", "Censer Y", "Number", delegate(GameObject o)
			{
				PlayMakerFSM val = FSMUtility.LocateMyFSM(o, "Control");
				FsmGameObject val2 = val.FsmVariables.FindFsmGameObject("Censer Throw");
				return Object.op_Implicit((Object)(object)val2.value) ? Extensions.GetPositionY(val2.value.transform) : 0f;
			}))
		});
	}
	public static class ReceiverGroup
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_0
		{
			public GameObject moveTo;

			internal bool <TakeControl>b__0(HeroController hero)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				hero.transform.position = moveTo.transform.position;
				return true;
			}
		}

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

			private object <>2__current;

			public GameObject o;

			private ParticleSystem[] <>s__1;

			private int <>s__2;

			private ParticleSystem <s>5__3;

			private ParticleSystem[] <>s__4;

			private int <>s__5;

			private ParticleSystem <s>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = null;
				<s>5__3 = null;
				<>s__4 = null;
				<s>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>s__1 = o.GetComponentsInChildren<ParticleSystem>();
					for (<>s__2 = 0; <>s__2 < <>s__1.Length; <>s__2++)
					{
						<s>5__3 = <>s__1[<>s__2];
						<s>5__3.Play();
						<s>5__3 = null;
					}
					<>s__1 = null;
					<>2__current = (object)new WaitForSeconds(o.GetComponent<MiscFixers.Dust>().time);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)o))
					{
						return false;
					}
					<>s__4 = o.GetComponentsInChildren<ParticleSystem>();
					for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
					{
						<s>5__6 = <>s__4[<>s__5];
						<s>5__6.Stop();
						<s>5__6 = null;
					}
					<>s__4 = null;
					o.BroadcastEvent("OnFinish");
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public DialDoorBridge ddb;

			public int direction;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ddb.isRotated = !ddb.isRotated;
					<>2__current = ddb.MoveRotate((float)direction);
					<>1__state = 2;
					return true;
				case 2:
					<>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();
			}
		}

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

			private object <>2__current;

			public GameObject moveTo;

			private <>c__DisplayClass12_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass12_0();
					<>8__1.moveTo = moveTo;
					<>2__current = HeroController.instance.FreeControl(delegate(HeroController hero)
					{
						//IL_0012: Unknown result type (might be due to invalid IL or missing references)
						hero.transform.position = <>8__1.moveTo.transform.position;
						return true;
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					HeroController.instance.transform.position = <>8__1.moveTo.transform.position;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public GameObject o;

			private TransitionPoint <tp>5__1;

			private bool <wasADoor>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<tp>5__1 = o.GetComponent<TransitionPoint>();
					<wasADoor>5__2 = <tp>5__1.isADoor;
					<tp>5__1.isADoor = false;
					<>2__current = HeroController.instance.FreeControl();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((InteractableBase)<tp>5__1).OnTriggerEnter2D(((Component)HeroController.instance).GetComponent<Collider2D>());
					if (<wasADoor>5__2)
					{
						<tp>5__1.isADoor = true;
					}
					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 static readonly List<EventReceiverType> Generic = new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("disable", "Disable", delegate(GameObject o)
			{
				o.SetActive(false);
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("enable", "Enable", delegate(GameObject o)
			{
				o.SetActive(true);
			}, runWhenInactive: true))
		};

		public static readonly List<EventReceiverType> ObjectHook = new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("hook_disable_target", "Disable", delegate(GameObject o)
			{
				ObjectHook component13 = o.GetComponent<ObjectHook>();
				component13.FindObject();
				GameObject o3 = component13.o;
				if (Object.op_Implicit((Object)(object)o3))
				{
					o3.SetActive(false);
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("hook_enable_target", "Enable", delegate(GameObject o)
			{
				ObjectHook component12 = o.GetComponent<ObjectHook>();
				component12.FindObject();
				GameObject o2 = component12.o;
				if (Object.op_Implicit((Object)(object)o2))
				{
					o2.SetActive(true);
				}
			}))
		};

		public static readonly List<EventReceiverType> Prefab = new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("prefab_start", "Activate", delegate(GameObject o)
			{
				o.SetActive(true);
			}, runWhenInactive: true)),
			EventManager.RegisterReceiverType(new EventReceiverType("prefab_destroy", "Destroy", delegate(GameObject o)
			{
				o.GetComponent<Prefab>().Destroy();
			}, runWhenInactive: true))
		};

		public static readonly List<EventReceiverType> AudioPlayer = new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("audio_player_play", "Play", delegate(GameObject o)
		{
			o.GetComponent<AudioPlayer>().Play();
		})) };

		public static readonly List<EventReceiverType> Wisp = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("wisp_go", "Fire", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Control").SetState("Fire Antic");
		})) });

		public static readonly List<EventReceiverType> FallingRock = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("falling_rock_fall", "Fall", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Control").SendEvent("STRIKE");
		})) });

		public static readonly List<EventReceiverType> Silkfly = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("silkfly_fly", "Fly", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Control").SendEvent("NEEDOLIN");
		})) });

		public static readonly List<EventReceiverType> ThreadEffect = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_thread", "Activate", delegate(GameObject o)
		{
			SilkPossession sp = o.GetComponent<MiscFixers.ThreadEffect>().sp;
			AudioSource componentInChildren3 = o.GetComponentInChildren<AudioSource>(true);
			if (Object.op_Implicit((Object)(object)componentInChildren3))
			{
				componentInChildren3.mute = false;
			}
			((Component)sp).gameObject.SetActive(true);
			sp.PlayPossess();
		})) });

		public static readonly List<EventReceiverType> Trobbiwork = new List<EventReceiverType>(3)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("do_burst", "Burst", delegate(GameObject o)
			{
				o.SetActive(false);
				((Behaviour)o.GetComponent<Animator>()).enabled = true;
				o.SetActive(true);
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("trobbiwork_disable", "Disable", delegate(GameObject o)
			{
				o.SetActive(false);
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("trobbiwork_enable", "Enable", delegate(GameObject o)
			{
				((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(3)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(4)).gameObject.SetActive(false);
				((Behaviour)o.GetComponent<Animator>()).enabled = false;
				o.SetActive(true);
			}, runWhenInactive: true))
		};

		public static readonly List<EventReceiverType> BindSource = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_bind_stab", "Stab", delegate(GameObject o)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(TakeControl(o));
			HeroController.instance.transform.position = o.transform.position;
			FSMUtility.LocateMyFSM(o, "Control").SendEvent("INTERACT");
		})) });

		public static readonly List<EventReceiverType> Shielder = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_shield_apply", "Apply", delegate(GameObject o)
		{
			o.GetComponent<Shielder>().Shield();
		})) });

		public static readonly List<EventReceiverType> MushTablet = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("mush_deactivate", "Deactivate", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Inspection").SetState("Inactive");
		})) });

		public static readonly List<EventReceiverType> AbilityCrystal = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("crystal_clear", "ClearAll", (Action<GameObject>)delegate
		{
			AbilityObjects.ActiveCrystals.Clear();
			AbilityObjects.RefreshCrystalUI();
		}, runWhenInactive: false)) });

		public static readonly List<EventReceiverType> ObjectLayerer = new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("layerer_apply", "Apply", delegate(GameObject o)
		{
			o.GetComponent<Layerer>().Apply();
		})) };

		public static readonly List<EventReceiverType> MagmaRocks = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("magma_go", "Away", delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").SendEvent("AWAY");
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("magma_back", "Return", delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").SendEvent("RETURN");
			}))
		});

		public static readonly List<EventReceiverType> Blast = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("servitor_blast", "Fire", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Control").SetState("Shoot");
		})) });

		public static readonly List<EventReceiverType> TriggerZone = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("disable_tz", "DisableImmediate", delegate(GameObject o)
		{
			o.GetComponent<TriggerZone>().block = true;
			o.SetActive(false);
		})) });

		public static readonly List<EventReceiverType> Ventrica = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("ventrica_leave", "Exit", delegate(GameObject o)
			{
				o.GetComponent<PlayMakerFSM>().SendEvent("CONTINUE");
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("ventrica_takeoff", "TakeOff", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					PlayMakerFSM component11 = o.GetComponent<PlayMakerFSM>();
					component11.FsmVariables.FindFsmString("To Scene").value = b.GetVariable<string>("To Scene");
					component11.FsmVariables.FindFsmString("Door Name").value = b.GetVariable<string>("To Door");
					component11.SetState("Preload Scene");
				}
			}))
		});

		public static readonly List<EventReceiverType> FsmHook = GroupUtils.Merge(Generic, new List<EventReceiverType>(4)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("fsm_set_state", "SetState", delegate(GameObject o)
			{
				o.GetComponent<FsmHook>().SetState();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("fsm_clear_transitions", "WipeAllTransitions", delegate(GameObject o)
			{
				o.GetComponent<FsmHook>().ClearEvents(all: true);
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("fsm_remove_transition", "WipeTransitions", delegate(GameObject o)
			{
				o.GetComponent<FsmHook>().ClearEvents();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("fsm_send_event", "SendEvent", delegate(GameObject o, ObjectBlock b)
			{
				o.GetComponent<FsmHook>().SendEvent(b.GetVariable<string>("Event"));
			}))
		});

		public static readonly List<EventReceiverType> ComponentHook = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("component_hook_apply", "Apply", delegate(GameObject o)
			{
				o.GetComponent<ComponentHook>().Setup();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("component_hook_set", "Set", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					o.GetComponent<ComponentHook>().SetValue(b.GetVariable<object>("New Value"));
				}
			}))
		});

		public static readonly List<EventReceiverType> Dust = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("dust_on", "Emit", delegate(GameObject o)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(EmitDust(o));
		})) });

		public static readonly List<EventReceiverType> Velocity = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("set_velocity", "SetVelocity", delegate(GameObject o, ObjectBlock b)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (b != null)
			{
				o.GetComponent<Rigidbody2D>().linearVelocity = new Vector2(b.GetVariable<float>("New X"), b.GetVariable<float>("New Y"));
			}
		})) });

		public static readonly List<EventReceiverType> MapperRing = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("set_velocity_ring", "SetVelocity", delegate(GameObject o, ObjectBlock b)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (b != null)
			{
				Rigidbody2D component10 = o.GetComponent<Rigidbody2D>();
				((Component)o.transform.GetChild(0)).gameObject.SetActive(true);
				component10.bodyType = (RigidbodyType2D)0;
				component10.linearVelocity = new Vector2(b.GetVariable<float>("New X"), b.GetVariable<float>("New Y"));
			}
		})) });

		public static readonly List<EventReceiverType> EnemyDamager = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("set_enemy_damager", "SetDamage", delegate(GameObject o, ObjectBlock b)
		{
			if (b != null)
			{
				o.GetComponent<DamageEnemies>().damageDealt = (int)b.GetVariable<float>("New Damage");
			}
		})) });

		public static readonly List<EventReceiverType> BounceFlea = GroupUtils.Merge(Generic, new List<EventReceiverType>(3)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("bounce_flea_fly", "FlyStraight", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					o.GetComponent<MiscFixers.BounceFlea>().Fly(b, "ENTER HIGH");
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("bounce_flea_wave", "FlyWave", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					o.GetComponent<MiscFixers.BounceFlea>().Fly(b, "ENTER WAVE");
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("bounce_flea_away", "FlyAway", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					FSMUtility.LocateMyFSM(o, "Control").SendEvent("END");
				}
			}))
		});

		public static readonly List<EventReceiverType> DodgeFlea = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("dodge_flea_fly", "Fly", delegate(GameObject o, ObjectBlock b)
		{
			if (b != null)
			{
				o.GetComponent<MiscFixers.DodgeFlea>().Fly(b);
			}
		})) });

		public static readonly List<EventReceiverType> Activatable = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("grow_pod", "Grow", delegate(GameObject o)
			{
				o.GetComponent<ActivatingBase>().SetActive(true, false);
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("shrink_pod", "Shrink", delegate(GameObject o)
			{
				o.GetComponent<ActivatingBase>().SetActive(false, false);
			}))
		});

		public static readonly List<EventReceiverType> BellPod = GroupUtils.Merge(Activatable, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("bell_pod_ring", "Ring", delegate(GameObject o)
		{
			o.GetComponentInChildren<BouncePod>(true).Ring(true);
		})) });

		public static readonly List<EventReceiverType> MaskAndSpool = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("collect_mask", "Collect", delegate(GameObject o)
		{
			o.GetComponent<PlayMakerFSM>().SendEvent("GET");
		})) });

		public static readonly List<EventReceiverType> Spine = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("spine_go", "Shoot", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Control").SendEvent("ANTIC");
		})) });

		public static readonly List<EventReceiverType> DialDoor = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("dial_rotate_l", "RotateLeft", delegate(GameObject o)
			{
				DialDoorBridge component9 = o.GetComponent<DialDoorBridge>();
				((MonoBehaviour)component9).StartCoroutine(RotateAfterFrame(component9, -1));
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("dial_rotate_r", "RotateRight", delegate(GameObject o)
			{
				DialDoorBridge component8 = o.GetComponent<DialDoorBridge>();
				((MonoBehaviour)component8).StartCoroutine(RotateAfterFrame(component8, 1));
			}))
		});

		public static readonly List<EventReceiverType> RuneBomb = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("bomb_trigger", "Activate", delegate(GameObject o)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			GameObject val9 = Object.Instantiate<GameObject>(((Component)o.transform.GetChild(0)).gameObject, o.transform.position, o.transform.localRotation);
			Vector3 localScale = val9.transform.localScale;
			localScale.x *= o.transform.localScale.x;
			localScale.y *= o.transform.localScale.x;
			val9.transform.localScale = localScale;
			val9.SetActive(true);
		})) });

		public static readonly List<EventReceiverType> VoidBullet = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("vb_trigger", "Activate", delegate(GameObject o)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val8 = Object.Instantiate<GameObject>(((Component)o.transform.GetChild(0)).gameObject, o.transform.position, o.transform.localRotation);
			((FlingObjectsFromGlobalPool)FSMUtility.LocateMyFSM(val8, "Control").GetState("Fire").actions[0]).gameObject = FsmGameObject.op_Implicit(((Component)o.transform.GetChild(1)).gameObject);
			val8.SetActive(true);
		})) });

		public static readonly List<EventReceiverType> SilkAcid = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("silk_acid_trigger", "Activate", delegate(GameObject o)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			GameObject val7 = Object.Instantiate<GameObject>(((Component)o.transform.GetChild(0)).gameObject, o.transform.position, o.transform.localRotation);
			FSMUtility.LocateMyFSM(val7, "Control").GetState("Idle").DisableAction(5);
			val7.SetActive(true);
		})) });

		public static readonly List<EventReceiverType> BlackThreader = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("do_black_thread", "Activate", delegate(GameObject o, ObjectBlock b)
			{
				HealthManager hm = null;
				if (b != null)
				{
					hm = b.GetVariable<HealthManager>("New Enemy");
				}
				o.GetComponent<BlackThreader>().BlackThread(hm);
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("queue_bts", "Queue Attack", delegate(GameObject o)
			{
				o.GetComponent<BlackThreader>().ForceAttack();
			}))
		});

		public static readonly List<EventReceiverType> Roar = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_roar", "Roar", delegate(GameObject o)
		{
			o.GetComponent<RoarEffect>().DoRoar();
		})) });

		public static readonly List<EventReceiverType> CoralSpike = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_rise", "Activate", delegate(GameObject o)
		{
			o.GetComponent<PlayMakerFSM>().SendEvent("SPIKE UP");
		})) });

		public static readonly List<EventReceiverType> Plasmifier = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_plasmify", "Activate", delegate(GameObject o)
		{
			o.GetComponent<Plasmifier>().Plasmify();
		})) });

		public static readonly List<EventReceiverType> Burst = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_zap", "Activate", delegate(GameObject o)
		{
			Transform child = o.transform.GetChild(0);
			((Component)child).gameObject.SetActive(true);
		})) });

		public static readonly List<EventReceiverType> Dropper = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("boulder_drop", "Drop", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Control").SendEvent("DROP");
		})) });

		public static readonly List<EventReceiverType> Pilby = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("pilby_die", "Die", delegate(GameObject o)
		{
			Transform val6 = o.transform.Find("Skull King Detector");
			((Component)val6).GetComponent<TriggerEvent>().OnTriggerEnter2D((Collider2D)(object)((Component)val6).GetComponent<BoxCollider2D>());
		})) });

		public static readonly List<EventReceiverType> CrankPlatform = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("crank_plat_reset", "Reset", delegate(GameObject o)
			{
				CrankPlat component7 = o.GetComponent<CrankPlat>();
				component7.isComplete = false;
				component7.posT = 0f;
				component7.SetCrankEnabled(true);
				component7.UpdatePos();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("crank_plat_hit", "Move", delegate(GameObject o)
			{
				CrankPlat component6 = o.GetComponent<CrankPlat>();
				float hitForce = component6.hitForce;
				component6.hitForce = 999999f;
				component6.DoHit();
				component6.hitForce = hitForce;
			}))
		});

		public static readonly List<EventReceiverType> PlayerDataSetter = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("pd_set", "SetValue", delegate(GameObject o)
			{
				o.GetComponent<PlayerDataSetter>().SetValue();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("pd_check", "Call", delegate(GameObject o)
			{
				o.GetComponent<PlayerDataSetter>().Relay();
			}))
		});

		public static readonly List<EventReceiverType> Bumpers = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("bouncer_evil", "SetFire", delegate(GameObject o)
			{
				o.GetComponent<Bumper>().SetEvil(newEvil: true);
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("bouncer_normal", "SetNormal", delegate(GameObject o)
			{
				o.GetComponent<Bumper>().SetEvil(newEvil: false);
			}))
		});

		public static readonly List<EventReceiverType> Item = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("item_pickup", "PickUp", delegate(GameObject o)
		{
			CollectableItemPickup componentInChildren2 = o.GetComponentInChildren<CollectableItemPickup>();
			componentInChildren2.canPickupTime = 0.0;
			componentInChildren2.DoPickupInstant();
		})) });

		public static readonly List<EventReceiverType> LifebloodCocoons = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("lifeblood_get", "Collect", delegate(GameObject o)
		{
			HealthFlyer[] componentsInChildren = o.GetComponentsInChildren<HealthFlyer>(true);
			foreach (HealthFlyer val5 in componentsInChildren)
			{
				GameManager.instance.AddBlueHealthQueued();
			}
		})) });

		public static readonly List<EventReceiverType> CameraShaker = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("camera_shake", "Shake", delegate(GameObject o)
		{
			o.GetComponent<CameraShaker>().Shake();
		})) });

		public static readonly List<EventReceiverType> TimeSlower = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_timechange", "SlowTime", delegate(GameObject o)
		{
			o.GetComponent<TimeSlower>().SlowTime();
		})) });

		public static readonly List<EventReceiverType> ObjectSpinner = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("spinner_reverse", "Reverse", delegate(GameObject o)
		{
			o.GetComponent<ObjectSpinner>().speed *= -1f;
		})) });

		public static readonly List<EventReceiverType> WalkTarget = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("start_walk", "Start", delegate(GameObject o)
			{
				o.GetComponent<WalkTarget>().StartWalk();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("end_walk", "Cancel", delegate(GameObject o)
			{
				o.GetComponent<WalkTarget>().StopWalk();
			}))
		});

		public static readonly List<EventReceiverType> Trap = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("activate_trap", "Activate", delegate(GameObject o)
		{
			PlayMakerFSM val4 = FSMUtility.LocateMyFSM(o, "Control") ?? FSMUtility.LocateMyFSM(o, "FSM");
			val4.SendEvent("ACTIVATE");
			val4.SendEvent("TRAP");
			val4.SendEvent("ROLL");
			val4.SendEvent("ATTACK");
		})) });

		public static readonly List<EventReceiverType> Gates = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("gate_open", "Open", delegate(GameObject o)
		{
			Gate component5 = o.GetComponent<Gate>();
			if (component5 != null)
			{
				((UnlockablePropBase)component5).Open();
			}
		})) });

		public static readonly List<EventReceiverType> AnimPlayer = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("play_anim", "Play", delegate(GameObject o)
			{
				o.GetComponent<PlayerAnimPlayer>().Play();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("stop_anim", "Stop", delegate(GameObject o)
			{
				o.GetComponent<PlayerAnimPlayer>().Stop();
			}))
		});

		public static readonly List<EventReceiverType> TeleportPoint = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("do_tp", "Teleport", delegate(GameObject o)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			HeroController.instance.transform.position = o.transform.position;
		})) });

		public static readonly List<EventReceiverType> CloseableGates = GroupUtils.Merge(Gates, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("gate_close", "Close", delegate(GameObject o)
		{
			o.GetComponent<Gate>().Close();
		})) });

		public static readonly List<EventReceiverType> BattleGate = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("bone_gate_close", "Close", delegate(GameObject o)
			{
				o.GetComponent<PlayMakerFSM>().SendEvent("BG CLOSE");
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("bone_gate_open", "Open", delegate(GameObject o)
			{
				o.GetComponent<PlayMakerFSM>().SendEvent("BG OPEN");
			}))
		});

		public static readonly List<EventReceiverType> Particles = GroupUtils.Merge(Generic, new List<EventReceiverType>(4)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("confetti_burst", "Burst", delegate(GameObject o, ObjectBlock b)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					ps.Emit(Mathf.RoundToInt(b?.GetVariable<float>("Count", 200) ?? 200f));
				});
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("particle_play", "Play", delegate(GameObject o)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					ps.Play();
				});
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("particle_pause", "Pause", delegate(GameObject o)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					ps.Pause();
				});
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("particle_stop", "Stop", delegate(GameObject o)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					ps.Stop();
				});
			}))
		});

		public static readonly List<EventReceiverType> Grass = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("grass_burst", "Burst", delegate(GameObject o, ObjectBlock b)
		{
			o.GetComponentInChildren<ParticleSystem>().Emit(Mathf.RoundToInt(b?.GetVariable<float>("Count", 20) ?? 20f));
		})) });

		public static readonly List<EventReceiverType> Displayable = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("display_text", "Show", delegate(GameObject o)
		{
			o.GetComponent<IDisplayable>().Display();
		})) });

		public static readonly List<EventReceiverType> FleaCounter = GroupUtils.Merge(Generic, new List<EventReceiverType>(5)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("increment_score", "Increment", delegate(GameObject o)
			{
				o.GetComponent<MiscFixers.CustomFleaCounter>().Increment();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("decrement_score", "Decrement", delegate(GameObject o)
			{
				o.GetComponent<MiscFixers.CustomFleaCounter>().Decrement();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("show_score", "ShowTitle", delegate(GameObject o)
			{
				o.GetComponent<MiscFixers.CustomFleaCounter>().Announce();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("reset_score", "Reset", delegate(GameObject o)
			{
				o.GetComponent<MiscFixers.CustomFleaCounter>().Reset();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("set_score", "Set", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					o.GetComponent<MiscFixers.CustomFleaCounter>().SetValue(b.GetVariable<float>("New Value"));
				}
			}))
		});

		public static readonly List<EventReceiverType> Playable = GroupUtils.Merge(Generic, new List<EventReceiverType>(3)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("start_play", "Play", delegate(GameObject o)
			{
				o.GetComponent<IPlayable>().Play();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("stop_play", "Pause", delegate(GameObject o)
			{
				o.GetComponent<IPlayable>().Pause();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("reset_play", "Reset", delegate(GameObject o)
			{
				o.GetComponent<IPlayable>().Reset();
			}))
		});

		public static readonly List<EventReceiverType> Png = GroupUtils.Merge(Playable, new List<EventReceiverType>(6)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("png_flip_x", "FlipX", delegate(GameObject o)
			{
				Extensions.SetScaleX(o.transform, 0f - Extensions.GetScaleX(o.transform));
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("png_flip_y", "FlipY", delegate(GameObject o)
			{
				Extensions.SetScaleY(o.transform, 0f - Extensions.GetScaleY(o.transform));
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("png_set_width", "SetWidth", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					Extensions.SetScaleX(o.transform, b.GetVariable<float>("New Width", 1));
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("png_set_height", "SetHeight", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					Extensions.SetScaleY(o.transform, b.GetVariable<float>("New Height", 1));
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("png_set_frame", "SetFrame", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					o.GetComponent<PngObject>().SetFrame(Mathf.RoundToInt(b.GetVariable<float>("New Frame", 1)));
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("png_set_fps", "SetFPS", delegate(GameObject o, ObjectBlock b)
			{
				if (b != null)
				{
					PngObject componentInChildren = o.GetComponentInChildren<PngObject>();
					float variable2 = b.GetVariable<float>("New FPS", 1);
					if (variable2 == 0f)
					{
						componentInChildren.frameTime = 0f;
					}
					else
					{
						componentInChildren.frameTime = 1f / Mathf.Max(0.01f, variable2);
					}
				}
			}))
		});

		public static readonly List<EventReceiverType> Wav = GroupUtils.Merge(Playable, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("set_volume", "SetVolume", delegate(GameObject o, ObjectBlock b)
		{
			if (b != null)
			{
				o.GetComponent<WavObject>().Volume = b.GetVariable<float>("New Volume");
			}
		})) });

		public static readonly List<EventReceiverType> PlayerHooks = GroupUtils.Merge(Generic, new List<EventReceiverType>(11)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("damage_player", "Damage", PlayerHook.DamagePlayer)),
			EventManager.RegisterReceiverType(new EventReceiverType("hazard_player", "HazardDamage", PlayerHook.HazardDamagePlayer)),
			EventManager.RegisterReceiverType(new EventReceiverType("kill_player", "Kill", PlayerHook.KillPlayer)),
			EventManager.RegisterReceiverType(new EventReceiverType("silk_player", "GiveSilk", (Action<GameObject>)delegate
			{
				PlayerHook.GiveSilk();
			}, runWhenInactive: false)),
			EventManager.RegisterReceiverType(new EventReceiverType("full_silk_player", "MaxSilk", (Action<GameObject>)delegate
			{
				PlayerHook.MaxSilk();
			}, runWhenInactive: false)),
			EventManager.RegisterReceiverType(new EventReceiverType("unsilk_player", "TakeSilk", (Action<GameObject>)delegate
			{
				PlayerHook.TakeSilk();
			}, runWhenInactive: false)),
			EventManager.RegisterReceiverType(new EventReceiverType("no_silk_player", "ClearSilk", (Action<GameObject>)delegate
			{
				PlayerHook.ClearSilk();
			}, runWhenInactive: false)),
			EventManager.RegisterReceiverType(new EventReceiverType("heal_player", "Heal", (Action<GameObject>)delegate
			{
				PlayerHook.HealPlayer();
			}, runWhenInactive: false)),
			EventManager.RegisterReceiverType(new EventReceiverType("full_heal_player", "FullHeal", (Action<GameObject>)delegate
			{
				PlayerHook.FullHealPlayer();
			}, runWhenInactive: false)),
			EventManager.RegisterReceiverType(new EventReceiverType("disable_vignette", "VignetteOff", (Action<GameObject>)delegate
			{
				PlayerHook.DisableVignette();
			}, runWhenInactive: false)),
			EventManager.RegisterReceiverType(new EventReceiverType("enable_vignette", "VignetteOn", (Action<GameObject>)delegate
			{
				PlayerHook.EnableVignette();
			}, runWhenInactive: false))
		});

		public static readonly List<EventReceiverType> Duplicator = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("duplicate", "SpawnObject", delegate(GameObject o)
		{
			o.GetComponent<ObjectDuplicator>().Duplicate();
		})) });

		public static readonly List<EventReceiverType> HazardRespawn = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("set_spawn", "SetSpawn", delegate(GameObject o)
		{
			PlayerData.instance.SetHazardRespawn(o.GetComponent<HazardRespawnMarker>());
		})) });

		public static readonly List<EventReceiverType> Respawn = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("set_bench_spawn", "SetSpawn", delegate(GameObject o)
		{
			PlayerData.instance.SetBenchRespawn(o.GetComponent<RespawnMarker>(), GameManager.instance.sceneName, 0);
		})) });

		public static readonly List<EventReceiverType> ObjectAnchor = GroupUtils.Merge(Generic, new List<EventReceiverType>(3)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("anchor_reset", "Reset", delegate(GameObject o)
			{
				o.GetComponent<ObjectAnchor>().Reset();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("anchor_stop", "StopMoving", delegate(GameObject o)
			{
				o.GetComponent<ObjectAnchor>().moving = false;
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("anchor_start", "StartMoving", delegate(GameObject o)
			{
				o.GetComponent<ObjectAnchor>().moving = true;
			}))
		});

		public static readonly List<EventReceiverType> ObjectMover = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("mover_move", "Move", delegate(GameObject o, ObjectBlock b)
		{
			o.GetComponent<ObjectMover>().Move(b?.GetVariable<float>("Extra X") ?? 0f, b?.GetVariable<float>("Extra Y") ?? 0f, b?.GetVariable<float>("Extra Rot") ?? 0f);
		})) });

		public static readonly List<EventReceiverType> Relay = new List<EventReceiverType>(3)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("do_relay", "Call", delegate(GameObject o)
			{
				o.GetComponent<Relay>().DoRelay();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("relay_off", "Disable", delegate(GameObject o)
			{
				o.GetComponent<Relay>().DisableRelay();
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("relay_on", "Enable", delegate(GameObject o)
			{
				o.GetComponent<Relay>().EnableRelay();
			}))
		};

		public static readonly List<EventReceiverType> Enemies = GroupUtils.Merge(Generic, new List<EventReceiverType>(3)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("enemy_die", "Die", delegate(GameObject o)
			{
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				HealthManager val3 = o.GetComponentInChildren<HealthManager>();
				if (!Object.op_Implicit((Object)(object)val3))
				{
					EnemyHook component4 = o.GetComponent<EnemyHook>();
					if (!Object.op_Implicit((Object)(object)component4))
					{
						return;
					}
					if (!Object.op_Implicit((Object)(object)component4.hm))
					{
						component4.DoCheck();
					}
					val3 = component4.hm;
				}
				if (Object.op_Implicit((Object)(object)val3))
				{
					EnemyFixers.DeathMarker orAddComponent = ((Component)val3).gameObject.GetOrAddComponent<EnemyFixers.DeathMarker>();
					if (!(Time.time - orAddComponent.time < 0.1f))
					{
						orAddComponent.time = Time.time;
						val3.TakeDamage(new HitInstance
						{
							Source = o,
							AttackType = (AttackTypes)1,
							NailElement = (NailElements)0,
							DamageDealt = 999999999,
							ToolDamageFlags = (ToolDamageFlags)0,
							SpecialType = (SpecialTypes)0,
							SlashEffectOverrides = Array.Empty<GameObject>(),
							IgnoreInvulnerable = true,
							HitEffectsType = (EffectsTypes)1,
							SilkGeneration = (HitSilkGeneration)2,
							Multiplier = 1f
						});
					}
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("enemy_invul", "MakeInvulnerable", delegate(GameObject o)
			{
				HealthManager val2 = o.GetComponentInChildren<HealthManager>();
				if (!Object.op_Implicit((Object)(object)val2))
				{
					EnemyHook component3 = o.GetComponent<EnemyHook>();
					if (!Object.op_Implicit((Object)(object)component3))
					{
						return;
					}
					if (!Object.op_Implicit((Object)(object)component3.hm))
					{
						component3.DoCheck();
					}
					val2 = component3.hm;
				}
				if (Object.op_Implicit((Object)(object)val2))
				{
					((Component)val2).gameObject.GetOrAddComponent<ConfigGroup.EnemyInvulnerabilityMarker>();
				}
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("enemy_vul", "MakeVulnerable", delegate(GameObject o)
			{
				HealthManager val = o.GetComponentInChildren<HealthManager>();
				if (!Object.op_Implicit((Object)(object)val))
				{
					EnemyHook component2 = o.GetComponent<EnemyHook>();
					if (!Object.op_Implicit((Object)(object)component2))
					{
						return;
					}
					if (!Object.op_Implicit((Object)(object)component2.hm))
					{
						component2.DoCheck();
					}
					val = component2.hm;
				}
				if (Object.op_Implicit((Object)(object)val))
				{
					((Component)val).gameObject.RemoveComponent<ConfigGroup.EnemyInvulnerabilityMarker>();
				}
			}))
		});

		public static readonly List<EventReceiverType> EnemyHook = GroupUtils.Merge(Enemies, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("enemy_hook_set", "SetEnemy", delegate(GameObject o, ObjectBlock b)
		{
			EnemyHook component = o.GetComponent<EnemyHook>();
			if (Object.op_Implicit((Object)(object)component))
			{
				HealthManager variable = b.GetVariable<HealthManager>("New Enemy");
				component.Set(variable);
			}
		})) });

		public static readonly List<EventReceiverType> FourthChorus = GroupUtils.Merge(Enemies, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("disable_chorus_plats", "RemovePlats", delegate(GameObject o)
		{
			GameObject plats = o.GetComponent<EnemyFixers.FourthChorus>().plats;
			if (Object.op_Implicit((Object)(object)plats))
			{
				plats.SetActive(false);
			}
		})) });

		public static readonly List<EventReceiverType> Garpid = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("garpid_attack", "Attack", delegate(GameObject o)
		{
			FSMUtility.LocateMyFSM(o, "Control").SendEvent("ALERT");
		})) });

		public static readonly List<EventReceiverType> Wakeable = GroupUtils.Merge(Enemies, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("enemy_wake", "Wake", delegate(GameObject o)
		{
			o.GetComponent<EnemyFixers.Wakeable>().DoWake();
		})) });

		public static readonly List<EventReceiverType> Binoculars = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("start_using", "StartUsing", delegate(GameObject o)
		{
			o.GetComponent<Binoculars>().StartUsing();
		})) });

		public static readonly List<EventReceiverType> SpikeBall = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("swing_1", "Swing", delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").SendEvent("TRAP");
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("swing_2", "SwingTwice", delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").SendEvent("TRAP DOUBLE");
			}))
		});

		public static readonly List<EventReceiverType> Colourer = GroupUtils.Merge(Generic, new List<EventReceiverType>(2)
		{
			EventManager.RegisterReceiverType(new EventReceiverType("do_colour", "Colour", delegate(GameObject o, ObjectBlock b)
			{
				o.GetComponent<ObjectColourer>().Apply(Mathf.Max(0f, b?.GetVariable<float>("Fade Time") ?? 0f));
			})),
			EventManager.RegisterReceiverType(new EventReceiverType("do_colour_dynamic", "DynamicColour", delegate(GameObject o, ObjectBlock b)
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				o.GetComponent<ObjectColourer>().Apply(Mathf.Max(0f, b.GetVariable<float>("Fade Time")), (Color?)new Color(b.GetVariable<float>("R", 1), b.GetVariable<float>("G", 1), b.GetVariable<float>("B", 1), b.GetVariable<float>("A", 1)));
			}))
		});

		public static readonly List<EventReceiverType> Transitions = GroupUtils.Merge(Generic, new List<EventReceiverType>(1) { EventManager.RegisterReceiverType(new EventReceiverType("transition", "Transition", delegate(GameObject o)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Transition(o));
		})) });

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

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

		[IteratorStateMachine(typeof(<RotateAfterFrame>d__33))]
		private static IEnumerator RotateAfterFrame(DialDoorBridge ddb, int direction)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RotateAfterFrame>d__33(0)
			{
				ddb = ddb,
				direction = direction
			};
		}

		[IteratorStateMachine(typeof(<Transition>d__82))]
		private static IEnumerator Transition(GameObject o)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Transition>d__82(0)
			{
				o = o
			};
		}
	}
	public enum RotationGroup
	{
		None,
		Vertical,
		Three,
		Four,
		Eight,
		All
	}
}
namespace Architect.Objects.Categories
{
	public abstract class AbstractCategory
	{
		public abstract List<SelectableObject> GetObjects();

		public abstract string GetName();
	}
	public class AllCategory : AbstractCategory
	{
		public static readonly AllCategory Instance = new AllCategory();

		private static List<SelectableObject> _objects;

		public override List<SelectableObject> GetObjects()
		{
			return _objects ?? (_objects = (from category in Categories.AllCategories.OfType<Category>()
				where category.Priority >= 0f
				orderby category.Priority
				select category).SelectMany((Category category) => category.GetObjects()).ToList());
		}

		public override string GetName()
		{
			return "All";
		}
	}
	public class BlankCategory : AbstractCategory
	{
		public static readonly BlankCategory Instance = new BlankCategory();

		public override List<SelectableObject> GetObjects()
		{
			return new List<SelectableObject>();
		}

		[CanBeNull]
		public override string GetName()
		{
			return null;
		}
	}
	public static class Categories
	{
		public static readonly List<AbstractCategory> AllCategories = new List<AbstractCategory>();

		public static readonly Category Misc = RegisterCategory("Miscellaneous", 9);

		public static readonly Category Npcs = RegisterCategory("Npcs", 7);

		public static readonly Category Effects = RegisterCategory("Effects", 8);

		public static readonly Category Attacks = RegisterCategory("Attacks", 6);

		public static readonly Category Hazards = RegisterCategory("Hazards", 5);

		public static readonly Category Interactable = RegisterCategory("Interactable", 4);

		public static readonly Category Solids = RegisterCategory("Solids", 3);

		public static readonly Category Platforming = RegisterCategory("Platforming", 2);

		public static readonly Category Enemies = RegisterCategory("Enemies", 1);

		public static readonly Category Utility = RegisterCategory("Utility", 11);

		public static readonly Category Legacy = new Category("Legacy", -1);

		public static readonly Category Abilities = RegisterCategory("Abilities", 9);

		public static readonly AbstractCategory All = RegisterCategory(AllCategory.Instance);

		public static void Init()
		{
			RegisterCategory(BlankCategory.Instance);
			RegisterCategory(SavedCategory.Instance);
			RegisterCategory(FavouritesCategory.Instance);
			RegisterCategory(BlankCategory.Instance);
			RegisterCategory(Legacy);
		}

		public static Category RegisterCategory(string name, int priority = 0)
		{
			Category category = new Category(name, priority);
			RegisterCategory(category);
			return category;
		}

		public static AbstractCategory RegisterCategory(AbstractCategory category)
		{
			AllCategories.Add(category);
			return category;
		}
	}
	public class Category : AbstractCategory
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <name>P;

		public readonly float Priority;

		private readonly List<SelectableObject> _objects;

		public Category(string name, int priority)
		{
			<name>P = name;
			Priority = priority;
			_objects = new List<SelectableObject>();
			base..ctor();
		}

		public PlaceableObject Add(PlaceableObject obj)
		{
			_objects.Add(obj);
			return obj;
		}

		public PlaceableObject AddStart(PlaceableObject obj)
		{
			_objects.Insert(0, obj);
			return obj;
		}

		public override List<SelectableObject> GetObjects()
		{
			return _objects;
		}

		[CanBeNull]
		public override string GetName()
		{
			return <name>P;
		}
	}
	public class FavouritesCategory : AbstractCategory
	{
		public static readonly FavouritesCategory Instance = new FavouritesCategory();

		public static List<string> Favourites;

		public override List<SelectableObject> GetObjects()
		{
			return ((IEnumerable<string>)Favourites).Select((Func<string, SelectableObject>)((string id) => PlaceableObject.RegisteredObjects[id])).ToList();
		}

		[CanBeNull]
		public override string GetName()
		{
			return "Favourites";
		}

		public static bool ToggleFavourite(PlaceableObject obj)
		{
			if (Favourites.Contains(obj.GetId()))
			{
				Favourites.Remove(obj.GetId());
				return false;
			}
			Favourites.Add(obj.GetId());
			return true;
		}

		public static bool IsFavourite(PlaceableObject obj)
		{
			string id = obj.GetId();
			return Favourites.Contains(id);
		}
	}
	public class PrefabsCategory : AbstractCategory
	{
		public static readonly PrefabsCategory Instance = new PrefabsCategory();

		public static List<PrefabObject> Prefabs;

		public override List<SelectableObject> GetObjects()
		{
			return Prefabs.Cast<SelectableObject>().ToList();
		}

		[CanBeNull]
		public override string GetName()
		{
			return "Prefabs";
		}

		public static void Remove(string name)
		{
			Prefabs.RemoveAll((PrefabObject o) => o.Name == name);
			if (EditorUI.CurrentCategory == Instance)
			{
				EditorUI.PageIndex = 0;
				EditorUI.DoRefreshCurrentPage();
			}
		}

		public static void Add(string name, LevelData data)
		{
			PrefabObject prefabObject = Prefabs.FirstOrDefault((PrefabObject o) => o.Name == name);
			if (prefabObject == null)
			{
				Prefabs.Add(new PrefabObject(name, data));
			}
			else
			{
				prefabObject.RefreshConfig(data);
			}
		}
	}
	public class SavedCategory : AbstractCategory
	{
		public static readonly SavedCategory Instance = new SavedCategory();

		public static List<SavedObject> Objects;

		public override List<SelectableObject> GetObjects()
		{
			return Objects.Cast<SelectableObject>().ToList();
		}

		[CanBeNull]
		public override string GetName()
		{
			return "Saved";
		}

		public static void RemovePrefab(SavedObject saved)
		{
			Objects.Remove(saved);
		}

		public static void AddPrefab(SavedObject saved)
		{
			Objects.Add(saved);
		}
	}
}
namespace Architect.Multiplayer
{
	public abstract class CoopManager
	{
		public static CoopManager Instance;

		public abstract string Name { get; }

		public static void Init()
		{
			if (Chainloader.PluginInfos.ContainsKey("ssmp"))
			{
				SsmpManagerInitializer.Init();
			}
			else
			{
				Instance = new DummyManager();
			}
		}

		public abstract bool IsActive();

		public abstract void ResetRoom(string room);

		public abstract void MoveObjects(string room, List<(string, Vector3)> movements);

		public abstract void EraseObjects(string room, List<string> ids);

		public abstract void ToggleTiles(string room, List<(int, int)> tiles, bool empty);

		public abstract void ToggleLock(string room, string id);

		public abstract void PlaceObjects(string room, List<ObjectPlacement> placements);

		public abstract void ShareScene(string room, bool scriptOnly, LevelData data);

		public abstract void RefreshRoom();

		public abstract void ShareEvent(string room, string name);
	}
	public class DummyManager : CoopManager
	{
		public override string Name => "Dummy";

		public override bool IsActive()
		{
			return false;
		}

		public override void ResetRoom(string room)
		{
		}

		public override void RefreshRoom()
		{
		}

		public override void ShareEvent(string room, string name)
		{
		}

		public override void MoveObjects(string room, List<(string, Vector3)> _)
		{
		}

		public override void EraseObjects(string room, List<string> _)
		{
		}

		public override void ToggleLock(string room, string _)
		{
		}

		public override void ToggleTiles(string room, List<(int, int)> tiles, bool empty)
		{
		}

		public override void PlaceObjects(string room, List<ObjectPlacement> _)
		{
		}

		public override void ShareScene(string room, bool scriptOnly, LevelData data)
		{
		}
	}
}
namespace Architect.Multiplayer.Ssmp
{
	public class ArchitectClientAddon : ClientAddon
	{
		[CompilerGenerated]
		private sealed class <SaveData>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LevelData levelData;

			public PlacePacketData packet;

			private LevelData <scene>5__1;

			private IEnumerator<ObjectPlacement> <>s__2;

			private ObjectPlacement <placement>5__3;

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

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

			[DebuggerHidden]
			public <SaveData>d__17(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();
					}
				}
				<scene>5__1 = null;
				<>s__2 = null;
				<placement>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						<placement>5__3 = null;
					}
					else
					{
						<>1__state = -1;
						if (packet.IsScriptOnly)
						{
							<scene>5__1 = StorageManager.LoadScene(packet.SceneName);
							<scene>5__1.ScriptBlocks.Clear();
							<scene>5__1.Comments.Clear();
							<scene>5__1.ScriptBlocks.AddRange(levelData.ScriptBlocks);
							<scene>5__1.Comments.AddRange(levelData.Comments);
							StorageManager.SaveScene(packet.SceneName, <scene>5__1);
							<scene>5__1 = null;
							goto IL_019d;
						}
						<>s__2 = levelData.Placements.Where((ObjectPlacement p) => p.GetPlacementType() is PreloadObject preloadObject && !preloadObject.Loaded).GetEnumerator();
						<>1__state = -3;
					}
					if (<>s__2.MoveNext())
					{
						<placement>5__3 = <>s__2.Current;
						<>2__current = <placement>5__3.GetPlacementType().EnsureLoaded();
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__2 = null;
					StorageManager.WipeScheduledEdits(packet.SceneName);
					StorageManager.SaveScene(packet.SceneName, levelData);
					goto IL_019d;
					IL_019d:
					if (packet.SceneName == GameManager.instance.sceneName || packet.SceneName == "Global")
					{
						PlacementManager.InvalidateScene();
						PlacementManager.VerifyLevelData();
						EditManager.ReloadRequired = true;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			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 (<>s__2 != null)
				{
					<>s__2.Dispose();
				}
			}

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

		public IClientApi API;

		private object _updateManager;

		private MethodInfo _setEnterSceneData;

		private MethodInfo _getCurrentAnimationClip;

		private static readonly List<PlacePacketData> PlaceInfo = new List<PlacePacketData>();

		private static string _lastPlaceGuid;

		protected override string Name => "Architect";

		protected override string Version => Assembly.GetExecutingAssembly().GetName().Version.ToString();

		public override bool NeedsNetwork => true;

		public override uint ApiVersion => 1u;

		public override void Initialize(IClientApi clientApi)
		{
			API = clientApi;
			IClientAddonNetworkReceiver<PacketId> networkReceiver = clientApi.NetClient.GetNetworkReceiver<PacketId>((ClientAddon)(object)this, (Func<PacketId, IPacketData>)((PacketId id) => id.GetData()));
			networkReceiver.RegisterPacketHandler<ClearPacketData>(PacketId.Clear, (GenericClientPacketHandler<ClearPacketData>)HandleClear);
			networkReceiver.RegisterPacketHandler<PlacePacketData>(PacketId.Place, (GenericClientPacketHandler<PlacePacketData>)HandlePlace);
			networkReceiver.RegisterPacketHandler<ErasePacketData>(PacketId.Erase, (GenericClientPacketHandler<ErasePacketData>)HandleErase);
			networkReceiver.RegisterPacketHandler<LockPacketData>(PacketId.Lock, (GenericClientPacketHandler<LockPacketData>)HandleLock);
			networkReceiver.RegisterPacketHandler<EventPacketData>(PacketId.Event, (GenericClientPacketHandler<EventPacketData>)HandleEvent);
			networkReceiver.RegisterPacketHandler<MovePacketData>(PacketId.Move, (GenericClientPacketHandler<MovePacketData>)HandleMove);
			networkReceiver.RegisterPacketHandler<TilePacketData>(PacketId.Tiles, (GenericClientPacketHandler<TilePacketData>)HandleTiles);
			PropertyInfo property = ((object)API.NetClient).GetType().GetProperty("UpdateManager");
			_updateManager = property.GetGetMethod().Invoke(API.NetClient, Array.Empty<object>());
			_setEnterSceneData = _updateManager.GetType().GetMethod("SetEnterSceneData");
			FieldInfo field = ((object)API.ClientManager).GetType().GetField("_animationManager", BindingFlags.Instance | BindingFlags.NonPublic);
			object value = field.GetValue(API.ClientManager);
			_getCurrentAnimationClip = value.GetType().GetMethod("GetCurrentAnimationClip", BindingFlags.Static | BindingFlags.Public);
			EditManager.ToggleChecks.Add(() => !clientApi.UiManager.ChatBox.IsOpen);
		}

		private static void HandleClear(ClearPacketData packet)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Receiving Reset Packet");
			if (packet.SceneName == GameManager.instance.sceneName)
			{
				ActionManager.ReceiveAction(new ResetRoom());
			}
			else
			{
				ResetRoom.Execute(packet.SceneName);
			}
		}

		private static void HandlePlace(PlacePacketData packet)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Receiving Place Packet");
			if (packet.Guid != _lastPlaceGuid)
			{
				_lastPlaceGuid = packet.Guid;
				PlaceInfo.Clear();
			}
			PlaceInfo.Add(packet);
			if (PlaceInfo.Count != packet.Length)
			{
				return;
			}
			PlaceInfo.Sort((PlacePacketData o1, PlacePacketData o2) => o1.Index.CompareTo(o2.Index));
			string data = ZipUtils.Unzip(PlaceInfo.Select((PlacePacketData o) => o.SerializedObjects).Aggregate((byte[] a, byte[] b) => a.Concat(b).ToArray()));
			if (packet.IsFullScene)
			{
				LevelData levelData = StorageManager.DeserializeLevel(data);
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(SaveData(levelData, packet));
				return;
			}
			PlaceObjects placeObjects = new PlaceObjects(StorageManager.DeserializePlacements(data));
			if (packet.SceneName == GameManager.instance.sceneName)
			{
				ActionManager.ReceiveAction(placeObjects);
			}
			else
			{
				placeObjects.Execute(packet.SceneName);
			}
		}

		[IteratorStateMachine(typeof(<SaveData>d__17))]
		private static IEnumerator SaveData(LevelData levelData, PlacePacketData packet)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SaveData>d__17(0)
			{
				levelData = levelData,
				packet = packet
			};
		}

		private static void HandleErase(ErasePacketData packet)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Receiving Erase Packet");
			if (packet.SceneName == GameManager.instance.sceneName)
			{
				ActionManager.ReceiveAction(new EraseObject(PlacementManager.GetLevelData().Placements.Where((ObjectPlacement p) => packet.Removals.Remove(p.GetId())).ToList()));
			}
			else
			{
				EraseObject.Execute(packet.SceneName, packet.Removals);
			}
		}

		private static void HandleLock(LockPacketData packet)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Receiving Lock Packet");
			if (packet.SceneName == GameManager.instance.sceneName)
			{
				ObjectPlacement objectPlacement = PlacementManager.GetLevelData().Placements.FirstOrDefault((ObjectPlacement p) => p.GetId() == packet.Toggle);
				if (objectPlacement != null)
				{
					ActionManager.ReceiveAction(new ToggleLock(objectPlacement));
				}
			}
			else
			{
				ToggleLock.Execute(packet.SceneName, packet.Toggle);
			}
		}

		private static void HandleTiles(TilePacketData packet)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Receiving Tile Packet");
			ToggleTile toggleTile = new ToggleTile(packet.Tiles, packet.Empty);
			if (packet.SceneName == GameManager.instance.sceneName)
			{
				toggleTile.Execute();
			}
			else
			{
				toggleTile.Execute(packet.SceneName);
			}
		}

		private static void HandleMove(MovePacketData packet)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			ArchitectPlugin.Logger.LogInfo((object)"Receiving Move Packet");
			if (packet.SceneName == GameManager.instance.sceneName)
			{
				List<(ObjectPlacement, Vector3, Vector3)> list = new List<(ObjectPlacement, Vector3, Vector3)>();
				foreach (var movement in packet.Movements)
				{
					string id = movement.Item1;
					Vector3 item = movement.Item2;
					ObjectPlacement objectPlacement = PlacementManager.GetLevelData().Placements.FirstOrDefault((ObjectPlacement o) => o.GetId() == id);
					if (objectPlacement != null)
					{
						list.Add((objectPlacement, item, objectPlacement.GetPos()));
					}
				}
				ActionManager.ReceiveAction(new MoveObjects(list));
			}
			else
			{
				MoveObjects.Execute(packet.SceneName, packet.Movements);
			}
		}

		private static void HandleEvent(EventPacketData packet)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Receiving Event Packet");
			if (!(packet.SceneName != GameManager.instance.sceneName))
			{
				EventManager.BroadcastMp(packet.Event);
			}
		}

		public void RefreshRoom()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			ArchitectPlugin.Logger.LogInfo((object)"Refreshing Room");
			Transform transform = HeroController.instance.transform;
			object value = _getCurrentAnimationClip.Invoke(null, Array.Empty<object>());
			_setEnterSceneData.Invoke(_updateManager, new object[4]
			{
				GameManager.instance.sceneName,
				(object)new Vector2(transform.position.x, transform.position.y),
				Extensions.GetScaleX(transform) > 0f,
				Convert.ToUInt16(value)
			});
		}
	}
	public class ArchitectServerAddon : ServerAddon
	{
		public IServerApi API;

		protected override string Name => "Architect";

		protected override string Version => Assembly.GetExecutingAssembly().GetName().Version.ToString();

		public override bool NeedsNetwork => true;

		public override uint ApiVersion => 1u;

		public override void Initialize(IServerApi serverApi)
		{
			API = serverApi;
			IServerAddonNetworkReceiver<PacketId> networkReceiver = serverApi.NetServer.GetNetworkReceiver<PacketId>((ServerAddon)(object)this, (Func<PacketId, IPacketData>)((PacketId id) => id.GetData()));
			networkReceiver.RegisterPacketHandler<ClearPacketData>(PacketId.Clear, (GenericServerPacketHandler<ClearPacketData>)delegate(ushort id, ClearPacketData packet)
			{
				Share(id, (IPacketData)(object)packet, PacketId.Clear);
			});
			networkReceiver.RegisterPacketHandler<PlacePacketData>(PacketId.Place, (GenericServerPacketHandler<PlacePacketData>)delegate(ushort id, PlacePacketData packet)
			{
				Share(id, (IPacketData)(object)packet, PacketId.Place);
			});
			networkReceiver.RegisterPacketHandler<ErasePacketData>(PacketId.Erase, (GenericServerPacketHandler<ErasePacketData>)delegate(ushort id, ErasePacketData packet)
			{
				Share(id, (IPacketData)(object)packet, PacketId.Erase);
			});
			networkReceiver.RegisterPacketHandler<LockPacketData>(PacketId.Lock, (GenericServerPacketHandler<LockPacketData>)delegate(ushort id, LockPacketData packet)
			{
				Share(id, (IPacketData)(object)packet, PacketId.Lock);
			});
			networkReceiver.RegisterPacketHandler<EventPacketData>(PacketId.Event, (GenericServerPacketHandler<EventPacketData>)delegate(ushort id, EventPacketData packet)
			{
				Share(id, (IPacketData)(object)packet, PacketId.Event);
			});
			networkReceiver.RegisterPacketHandler<MovePacketData>(PacketId.Move, (GenericServerPacketHandler<MovePacketData>)delegate(ushort id, MovePacketData packet)
			{
				Share(id, (IPacketData)(object)packet, PacketId.Move);
			});
			networkReceiver.RegisterPacketHandler<TilePacketData>(PacketId.Tiles, (GenericServerPacketHandler<TilePacketData>)delegate(ushort id, TilePacketData packet)
			{
				Share(id, (IPacketData)(object)packet, PacketId.Tiles);
			});
		}

		private void Share(ushort id, IPacketData packet, PacketId packetId)
		{
			IServerAddonNetworkSender<PacketId> networkSender = API.NetServer.GetNetworkSender<PacketId>((ServerAddon)(object)this);
			List<ushort> list = new List<ushort>();
			foreach (IServerPlayer player in API.ServerManager.Players)
			{
				if (player.Id != id)
				{
					list.Add(player.Id);
				}
			}
			networkSender.SendSingleData(packetId, packet, list.ToArray());
		}
	}
	public enum PacketId
	{
		Clear,
		Move,
		Erase,
		Tiles,
		Lock,
		Place,
		Event
	}
	public static class PacketIdExtension
	{
		public static IPacketData GetData(this PacketId packetId)
		{
			if (1 == 0)
			{
			}
			IPacketData result = (IPacketData)(packetId switch
			{
				PacketId.Clear => new ClearPacketData(), 
				PacketId.Move => new MovePacketData(), 
				PacketId.Erase => new ErasePacketData(), 
				PacketId.Tiles => new TilePacketData(), 
				PacketId.Lock => new LockPacketData(), 
				PacketId.Place => new PlacePacketData(), 
				PacketId.Event => new EventPacketData(), 
				_ => null, 
			});
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class SsmpManager : CoopManager
	{
		private const int SPLIT_SIZE = 600;

		private readonly ArchitectClientAddon _clientAddon;

		public override string Name => "SSMP";

		public SsmpManager()
		{
			_clientAddon = new ArchitectClientAddon();
			ClientAddon.RegisterAddon((ClientAddon)(object)_clientAddon);
			ServerAddon.RegisterAddon((ServerAddon)(object)new ArchitectServerAddon());
		}

		private void SendPacket(PacketId id, IPacketData data)
		{
			_clientAddon.API.NetClient.GetNetworkSender<PacketId>((ClientAddon)(object)_clientAddon).SendSingleData(id, data);
		}

		public override bool IsActive()
		{
			return _clientAddon.API.NetClient.IsConnected;
		}

		public override void ResetRoom(string room)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Reset Packet");
			SendPacket(PacketId.Clear, (IPacketData)(object)new ClearPacketData
			{
				SceneName = room
			});
		}

		public override void MoveObjects(string room, List<(string, Vector3)> movements)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Move Packet");
			SendPacket(PacketId.Move, (IPacketData)(object)new MovePacketData
			{
				SceneName = room,
				Movements = movements
			});
		}

		public override void EraseObjects(string room, List<string> ids)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Erase Packet");
			SendPacket(PacketId.Erase, (IPacketData)(object)new ErasePacketData
			{
				SceneName = room,
				Removals = ids
			});
		}

		public override void ToggleTiles(string room, List<(int, int)> tiles, bool empty)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Tiles Packet");
			SendPacket(PacketId.Tiles, (IPacketData)(object)new TilePacketData
			{
				SceneName = room,
				Tiles = tiles,
				Empty = empty
			});
		}

		public override void ToggleLock(string room, string id)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Lock Packet");
			SendPacket(PacketId.Lock, (IPacketData)(object)new LockPacketData
			{
				SceneName = room,
				Toggle = id
			});
		}

		public override void PlaceObjects(string room, List<ObjectPlacement> placements)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Place Packet");
			string str = StorageManager.SerializePlacements(placements);
			byte[][] bytes = Split(ZipUtils.Zip(str), 600);
			Task.Run(() => SendSplitPlaceData(bytes, room, isFullScene: false, scriptOnly: false));
		}

		public override void ShareScene(string room, bool scriptOnly, LevelData data)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Scene Packet");
			string str = StorageManager.SerializeLevel(data, (Formatting)0);
			byte[][] bytes = Split(ZipUtils.Zip(str), 600);
			Task.Run(() => SendSplitPlaceData(bytes, room, isFullScene: true, scriptOnly));
		}

		private async Task SendSplitPlaceData(byte[][] bytes, string room, bool isFullScene, bool scriptOnly)
		{
			string guid = Guid.NewGuid().ToString();
			int i = 0;
			int length = bytes.Length;
			foreach (byte[] byteGroup in bytes)
			{
				SendPacket(PacketId.Place, (IPacketData)(object)new PlacePacketData
				{
					SceneName = room,
					SerializedObjects = byteGroup,
					Index = i,
					Length = length,
					Guid = guid,
					IsFullScene = isFullScene,
					IsScriptOnly = scriptOnly
				});
				i++;
				await Task.Delay(100);
			}
		}

		public override void RefreshRoom()
		{
			_clientAddon.RefreshRoom();
		}

		public static byte[][] Split(byte[] array, int size)
		{
			int num = Mathf.CeilToInt((float)array.Length / (float)size);
			byte[][] array2 = new byte[num][];
			for (int i = 0; i < num; i++)
			{
				array2[i] = array.Skip(i * size).Take(size).ToArray();
			}
			return array2;
		}

		public override void ShareEvent(string room, string name)
		{
			ArchitectPlugin.Logger.LogInfo((object)"Sending Event Packet");
			SendPacket(PacketId.Event, (IPacketData)(object)new EventPacketData
			{
				SceneName = room,
				Event = name
			});
		}
	}
	public static class SsmpManagerInitializer
	{
		public static void Init()
		{
			CoopManager.Instance = new SsmpManager();
		}
	}
}
namespace Architect.Multiplayer.Ssmp.Data
{
	public class ClearPacketData : ScenePacketData
	{
		protected override void WriteExtData(IPacket packet)
		{
		}

		protected override void ReadExtData(IPacket packet)
		{
		}
	}
	public class ErasePacketData : ScenePacketData
	{
		public List<string> Removals;

		protected override void WriteExtData(IPacket packet)
		{
			packet.Write(Removals.Count);
			foreach (string removal in Removals)
			{
				packet.Write(removal);
			}
		}

		protected override void ReadExtData(IPacket packet)
		{
			Removals = new List<string>();
			int num = packet.ReadInt();
			for (int i = 0; i < num; i++)
			{
				Removals.Add(packet.ReadString());
			}
		}
	}
	public class EventPacketData : ScenePacketData
	{
		public string Event;

		protected override void WriteExtData(IPacket packet)
		{
			packet.Write(Event);
		}

		protected override void ReadExtData(IPacket packet)
		{
			Event = packet.ReadString();
		}
	}
	public class LockPacketData : ScenePacketData
	{
		public string Toggle;

		protected override void WriteExtData(IPacket packet)
		{
			packet.Write(Toggle);
		}

		protected override void ReadExtData(IPacket packet)
		{
			Toggle = packet.ReadString();
		}
	}
	public class MovePacketData : ScenePacketData
	{
		public List<(string, Vector3)> Movements;

		protected override void WriteExtData(IPacket packet)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			packet.Write(Movements.Count);
			foreach (var movement in Movements)
			{
				packet.Write(movement.Item1);
				packet.Write(movement.Item2.x);
				packet.Write(movement.Item2.y);
				packet.Write(movement.Item2.z);
			}
		}

		protected override void ReadExtData(IPacket packet)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Movements = new List<(string, Vector3)>();
			int num = packet.ReadInt();
			for (int i = 0; i < num; i++)
			{
				Movements.Add((packet.ReadString(), new Vector3(packet.ReadFloat(), packet.ReadFloat(), packet.ReadFloat())));
			}
		}
	}
	public class PlacePacketData : ScenePacketData
	{
		public byte[] SerializedObjects;

		public string Guid;

		public int Index;

		public int Length;

		public bool IsFullScene;

		public bool IsScriptOnly;

		protected override void WriteExtData(IPacket packet)
		{
			packet.Write(IsFullScene);
			packet.Write(IsScriptOnly);
			packet.Write(Length);
			packet.Write(Index);
			packet.Write(Guid);
			packet.Write(SerializedObjects.Length);
			byte[] serializedObjects = SerializedObjects;
			foreach (byte b in serializedObjects)
			{
				packet.Write(b);
			}
		}

		protected override void ReadExtData(IPacket packet)
		{
			IsFullScene = packet.ReadBool();
			IsScriptOnly = packet.ReadBool();
			Length = packet.ReadInt();
			Index = packet.ReadInt();
			Guid = packet.ReadString();
			int num = packet.ReadInt();
			byte[] array = new byte[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = packet.ReadByte();
			}
			SerializedObjects = array;
		}
	}
	public abstract class ScenePacketData : IPacketData
	{
		public string SceneName;

		public bool IsReliable => true;

		public bool DropReliableDataIfNewerExists => false;

		public void WriteData(IPacket packet)
		{
			packet.Write(SceneName);
			WriteExtData(packet);
		}

		public void ReadData(IPacket packet)
		{
			SceneName = packet.ReadString();
			ReadExtData(packet);
		}

		protected abstract void WriteExtData(IPacket packet);

		protected abstract void ReadExtData(IPacket packet);
	}
	public class TilePacketData : ScenePacketData
	{
		public List<(int, int)> Tiles;

		public bool Empty;

		protected override void WriteExtData(IPacket packet)
		{
			packet.Write(Empty);
			packet.Write(Tiles.Count);
			foreach (var tile in Tiles)
			{
				packet.Write(tile.Item1);
				packet.Write(tile.Item2);
			}
		}

		protected override void ReadExtData(IPacket packet)
		{
			Empty = packet.ReadBool();
			Tiles = new List<(int, int)>();
			int num = packet.ReadInt();
			for (int i = 0; i < num; i++)
			{
				Tiles.Add((packet.ReadInt(), packet.ReadInt()));
			}
		}
	}
}
namespace Architect.Events
{
	public static class BroadcasterHooks
	{
		private class DoneRoar : MonoBehaviour
		{
		}

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

			private object <>2__current;

			public Func<HealthFlyer, IEnumerator> orig;

			public HealthFlyer self;

			private IEnumerator <o>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Component)self).gameObject.BroadcastEvent("OnDeath");
					<o>5__1 = orig(self);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<o>5__1.MoveNext())
				{
					<>2__current = <o>5__1.Current;
					<>1__state = 1;
					return true;
				}
				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 static void Init()
		{
			typeof(HealthManager).Hook("TakeDamage", (Action<Action<HealthManager, HitInstance>, HealthManager, HitInstance>)delegate(Action<HealthManager, HitInstance> orig, HealthManager self, HitInstance hitInstance)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				orig(self, hitInstance);
				if (!self.IsImmuneTo(hitInstance, true))
				{
					EventManager.BroadcastEvent(((Component)self).gameObject, "OnDamage");
				}
			});
			typeof(HealthManager).Hook("Die", (Action<Action<HealthManager, float?, AttackTypes, NailElements, GameObject, bool, float, bool, bool>, HealthManager, float?, AttackTypes, NailElements, GameObject, bool, float, bool, bool>)delegate(Action<HealthManager, float?, AttackTypes, NailElements, GameObject, bool, float, bool, bool> orig, HealthManager self, float? attackDirection, AttackTypes attackType, NailElements nailElement, GameObject damageSource, bool ignoreEvasion, float corpseFlingMultiplier, bool overrideSpecialDeath, bool disallowDropFling)
			{
				//IL_000b: 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)
				bool isDead = self.isDead;
				orig(self, attackDirection, attackType, nailElement, damageSource, ignoreEvasion, corpseFlingMultiplier, overrideSpecialDeath, disallowDropFling);
				if (!isDead)
				{
					((Component)self).gameObject.BroadcastEvent("OnDeath");
					((Component)self).gameObject.BroadcastEvent("FirstDeath");
					PersistentBoolItem component2 = ((Component)self).GetComponent<PersistentBoolItem>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						component2.SetValueOverride(true);
					}
				}
			}, typeof(float?), typeof(AttackTypes), typeof(NailElements), typeof(GameObject), typeof(bool), typeof(float), typeof(bool), typeof(bool));
			typeof(HealthManager).Hook("Awake", (Action<Action<HealthManager>, HealthManager>)delegate(Action<HealthManager> orig, HealthManager self)
			{
				PersistentBoolItem component = ((Component)self).GetComponent<PersistentBoolItem>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((PersistentItem<bool>)(object)component).OnSetSaveState += delegate(bool value)
					{
						if (value)
						{
							((Component)self).gameObject.BroadcastEvent("OnDeath");
						}
						if (value)
						{
							((Component)self).gameObject.BroadcastEvent("LoadedDead");
						}
					};
				}
				orig(self);
			});
			typeof(Lever_tk2d).Hook("Hit", (Func<Func<Lever_tk2d, HitInstance, HitResponse>, Lever_tk2d, HitInstance, HitResponse>)delegate(Func<Lever_tk2d, HitInstance, HitResponse> orig, Lever_tk2d self, HitInstance hit)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				bool flag2 = !self.activated;
				HitResponse result2 = orig(self, hit);
				if (flag2 && self.activated)
				{
					((Component)self).gameObject.BroadcastEvent("OnPull");
					((Component)self).gameObject.BroadcastEvent("FirstPull");
				}
				return result2;
			});
			typeof(Lever).Hook("Hit", (Func<Func<Lever, HitInstance, HitResponse>, Lever, HitInstance, HitResponse>)delegate(Func<Lever, HitInstance, HitResponse> orig, Lever self, HitInstance hit)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				bool flag = !self.activated;
				HitResponse result = orig(self, hit);
				if (flag && self.activated)
				{
					((Component)self).gameObject.BroadcastEvent("OnPull");
					((Component)self).gameObject.BroadcastEvent("FirstPull");
				}
				return result;
			});
			typeof(StartRoarEmitter).Hook("StartRoar", (Action<Action<StartRoarEmitter>, StartRoarEmitter>)delegate(Action<StartRoarEmitter> orig, StartRoarEmitter self)
			{
				GameObject gameObject2 = ((Component)((FsmStateAction)self).fsmComponent).gameObject;
				if (!Object.op_Implicit((Object)(object)gameObject2.GetComponent<DoneRoar>()))
				{
					gameObject2.AddComponent<DoneRoar>();
					gameObject2.BroadcastEvent("OnRoar");
				}
				orig(self);
			});
			typeof(StartRoarEmitterV2).Hook("StartRoar", (Action<Action<StartRoarEmitterV2>, StartRoarEmitterV2>)delegate(Action<StartRoarEmitterV2> orig, StartRoarEmitterV2 self)
			{
				GameObject gameObject = ((Component)((FsmStateAction)self).fsmComponent).gameObject;
				if (!Object.op_Implicit((Object)(object)gameObject.GetComponent<DoneRoar>()))
				{
					gameObject.AddComponent<DoneRoar>();
					gameObject.BroadcastEvent("OnRoar");
				}
				orig(self);
			});
			typeof(HealthFlyer).Hook("Heal", new Func<Func<HealthFlyer, IEnumerator>, HealthFlyer, IEnumerator>(DeathEvent));
		}

		[IteratorStateMachine(typeof(<DeathEvent>d__1))]
		private static IEnumerator DeathEvent(Func<HealthFlyer, IEnumerator> orig, HealthFlyer self)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeathEvent>d__1(0)
			{
				orig = orig,
				self = self
			};
		}
	}
	public static class EventManager
	{
		private static readonly Dictionary<string, EventReceiverType> ReceiverTypes = new Dictionary<string, EventReceiverType>();

		private static readonly Dictionary<string, OutputType> OutputTypes = new Dictionary<string, OutputType>();

		private static readonly Dictionary<string, List<LegacyReceiver>> Receivers = new Dictionary<string, List<LegacyReceiver>>();

		public static EventReceiverType RegisterReceiverType(EventReceiverType type)
		{
			return ReceiverTypes[type.Id] = type;
		}

		public static EventReceiverType GetReceiverType(string id)
		{
			return ReceiverTypes.GetValueOrDefault(id);
		}

		public static OutputType RegisterOutputType(OutputType type)
		{
			return OutputTypes[type.Id] = type;
		}

		public static OutputType GetOutputType(string id)
		{
			return OutputTypes.GetValueOrDefault(id);
		}

		public static void BroadcastMp(string eventName)
		{
			foreach (MultiplayerOutBlock.MpEvent item in MultiplayerOutBlock.MpEvent.Events.Where((MultiplayerOutBlock.MpEvent o) => o.Block.EventName == eventName))
			{
				item.Block.Event("OnReceive");
			}
		}

		public static void BroadcastEvent(GameObject obj, string triggerName)
		{
			if (Object.op_Implicit((Object)(object)obj))
			{
				LegacyBroadcaster[] components = obj.GetComponents<LegacyBroadcaster>();
				foreach (LegacyBroadcaster legacyBroadcaster in components)
				{
					legacyBroadcaster.Broadcast(triggerName);
				}
				ObjectBlock.ObjectBlockReference[] componentsInParent = obj.GetComponentsInParent<ObjectBlock.ObjectBlockReference>();
				foreach (ObjectBlock.ObjectBlockReference objectBlockReference in componentsInParent)
				{
					objectBlockReference.OnEvent(triggerName);
				}
			}
		}

		public static void ResetReceivers()
		{
			Receivers.Clear();
		}

		public static void RegisterReceiver(LegacyReceiver instance)
		{
			if (!Receivers.ContainsKey(instance.eventName))
			{
				Receivers[instance.eventName] = new List<LegacyReceiver>();
			}
			Receivers[instance.eventName].Add(instance);
		}

		public static void Broadcast(string eventName)
		{
			if (!Receivers.TryGetValue(eventName, out var value))
			{
				return;
			}
			value.RemoveAll((LegacyReceiver o) => !Object.op_Implicit((Object)(object)o));
			foreach (LegacyReceiver item in value.ToList())
			{
				item.ReceiveEvent(eventName);
			}
		}
	}
	public class EventReceiverType
	{
		public readonly string Id;

		public readonly string Name;

		public readonly Action<GameObject, ObjectBlock> Trigger;

		public readonly bool RunWhenInactive;

		public EventReceiverType(string id, string name, Action<GameObject, ObjectBlock> trigger, bool runWhenInactive = false)
		{
			Id = id;
			Name = name;
			Trigger = trigger;
			RunWhenInactive = runWhenInactive;
			base..ctor();
		}

		public EventReceiverType(string id, string name, Action<GameObject> trigger, bool runWhenInactive = false)
			: this(id, name, delegate(GameObject o, ObjectBlock _)
			{
				trigger(o);
			}, runWhenInactive)
		{
		}
	}
	public class LegacyBroadcaster : MonoBehaviour
	{
		public string triggerName;

		public string eventName;

		public void Broadcast(string trigger)
		{
			if (!(trigger != triggerName))
			{
				EventHooks.OnEvent?.Invoke(((Component)this).gameObject, eventName);
				EventManager.Broadcast(eventName);
			}
		}
	}
	public class LegacyReceiver : MonoBehaviour
	{
		public string eventName;

		public EventReceiverType ReceiverType;

		public int requiredCalls = 1;

		public int calls;

		public void ReceiveEvent(string eve)
		{
			if (ReceiverType == null || (!ReceiverType.RunWhenInactive && !((Component)this).gameObject.activeInHierarchy))
			{
				return;
			}
			calls++;
			if (calls < requiredCalls)
			{
				return;
			}
			calls = 0;
			try
			{
				ReceiverType.Trigger(((Component)this).gameObject, null);
			}
			catch (Exception ex)
			{
				ArchitectPlugin.Logger.LogError((object)ex);
			}
		}
	}
}
namespace Architect.Events.Vars
{
	public class OutputType
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <typeId>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Func<GameObject, object> <check>P;

		public readonly string Id;

		public readonly string Name;

		public OutputType(string id, string name, string typeId, Func<GameObject, object> check)
		{
			<typeId>P = typeId;
			<check>P = check;
			Id = id;
			Name = name;
			base..ctor();
		}

		public object GetValue(GameObject obj)
		{
			return <check>P(obj);
		}

		public string GetTypeId()
		{
			return <typeId>P;
		}
	}
}
namespace Architect.Events.Blocks
{
	public class Category
	{
		public string Name;

		public Color Colour;

		public static readonly List<Category> Categories = new List<Category>();

		public static readonly Category All = new Category("All", Color.white);

		public static readonly Category Events = new Category("Events", Color.green);

		public static readonly Category World = new Category("Player / World", new Color(0.6f, 0.5f, 0.9f));

		public static readonly Category Logic = new Category("Logic", new Color(0.9f, 0.7f, 0.3f));

		public static readonly Category Data = new Category("Data", new Color(0.9f, 0.5f, 0.2f));

		public static readonly Category Time = new Category("Time", Color.yellow);

		public static readonly Category Visual = new Category("Visual / UI", new Color(0.9f, 0.2f, 0.2f));

		public readonly List<(Func<ScriptBlock>, string)> Blocks = new List<(Func<ScriptBlock>, string)>();

		public Category(string name, Color colour)
		{
			//IL_001b: 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)
			Name = name;
			Colour = colour;
			Categories.Add(this);
		}

		public void RegisterBlock<T>(string id, List<Architect.Events.Blocks.Config.Types.ConfigType> configGroup = null, Action init = null) where T : ScriptBlock, new()
		{
			RegisterBlock<T>(id, id, configGroup, init);
		}

		public void RegisterBlock<T>(string id, string name, List<Architect.Events.Blocks.Config.Types.ConfigType> configGroup = null, Action init = null) where T : ScriptBlock, new()
		{
			init?.Invoke();
			Func<T> func = () => new T
			{
				Type = id,
				Config = configGroup,
				Position = Vector2.op_Implicit(ScriptManager.BlockSpawnPos),
				Color = Colour
			};
			Blocks.Add((func, name));
			ScriptManager.BlockTypes[id] = func;
		}

		public void RegisterHiddenBlock<T>(string name, List<Architect.Events.Blocks.Config.Types.ConfigType> configGroup = null) where T : ScriptBlock, new()
		{
			ScriptManager.BlockTypes[name] = () => new T
			{
				Type = name,
				Config = configGroup,
				Position = Vector2.op_Implicit(ScriptManager.BlockSpawnPos),
				Color = Colour
			};
		}
	}
	public abstract class LinkedBlock : ScriptBlock
	{
		public abstract void AddExtraIds(List<string> ids);
	}
	public abstract class CollectionBlock<T> : LinkedBlock where T : CollectionBlock<T>.ChildBlock, new()
	{
		public abstract class ChildBlock : LinkedBlock
		{
			public ChildrenGroup Group;

			public int BlockHeight;

			protected override string Name => null;

			public override bool CanCloneDirectly => false;

			protected override void SetupBlock(bool newBlock, int width, int height)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
				if (base.ConfigCount >= 3)
				{
					height += 25;
				}
				base.SetupBlock(newBlock, width, height);
				BlockInstance.overrideDrag = Group.Parent.BlockInstance;
				BlockHeight = height;
				if (Group.NeedsGap)
				{
					Image val = UIUtils.MakeImage("Connector", BlockObject, new Vector2(25f, 40f), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(50f, 170f));
					val.sprite = ScriptBlock.FlowchartBlock;
					val.type = (Type)1;
					((Graphic)val).color = Color;
				}
			}

			public override void Delete()
			{
				Group.Remove(this);
				base.Delete();
			}

			public override void AddExtraIds(List<string> ids)
			{
				ids.Add(Group.Parent.BlockId);
				foreach (T child in Group.Children)
				{
					ids.Add(child.BlockId);
				}
			}
		}

		public class ChildrenGroup
		{
			public ScriptBlock Parent;

			public List<ChildBlock> Blocks = new List<ChildBlock>();

			public bool NeedsGap;

			public RectTransform AddBlock;

			public int MaxChildren;

			public int Height;

			public IEnumerable<T> Children => Blocks.Where((ChildBlock o) => o is T).Cast<T>();

			public void Remove(ChildBlock block)
			{
				Blocks.Remove(block);
				OrderChildren();
			}

			public void OrderChildren()
			{
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				float num = -Height;
				bool flag = NeedsGap && Blocks.Count > 0;
				if (!NeedsGap)
				{
					num += 25f;
				}
				int num2 = 0;
				foreach (ChildBlock block in Blocks)
				{
					if (flag)
					{
						if (num2 > 0)
						{
							num -= 37.5f;
						}
						num -= 40f;
						num -= (float)block.BlockHeight / 2f;
					}
					if (Object.op_Implicit((Object)(object)block.BlockObject))
					{
						block.BlockObject.transform.localPosition = new Vector3(0f, num + (NeedsGap ? 12.5f : 0f));
					}
					num = ((!flag) ? (num - (float)block.BlockHeight) : (num - (float)block.BlockHeight / 2f));
					num2++;
				}
				Extensions.SetLocalPositionY((Transform)(object)AddBlock, num + (flag ? 84f : (NeedsGap ? 122.5f : 197.5f)));
				((Transform)AddBlock).SetAsLastSibling();
				if (MaxChildren > 0)
				{
					((Component)AddBlock).gameObject.SetActive(Blocks.Count < MaxChildren);
				}
			}
		}

		protected ChildrenGroup Children = new ChildrenGroup();

		protected abstract string ChildName { get; }

		protected virtual int MaxChildren => -1;

		protected abstract bool NeedsGap { get; }

		protected override Dictionary<string, string> SerializeExtraData()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary["children"] = JsonConvert.SerializeObject((object)Children.Blocks);
			return dictionary;
		}

		protected override void DeserializeExtraData(Dictionary<string, string> data)
		{
			Children = new ChildrenGroup
			{
				Blocks = JsonConvert.DeserializeObject<List<ChildBlock>>(data["children"], (JsonConverter[])(object)new JsonConverter[1] { (JsonConverter)ScriptBlock.Sbc })
			};
		}

		protected override void SetupBlock(bool newBlock, int width, int height)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0054: 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_0072: 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_00b1: Expected O, but got Unknown
			base.SetupBlock(newBlock, width, height);
			if (!Object.op_Implicit((Object)(object)BlockObject))
			{
				return;
			}
			GameObject val = new GameObject("Add Area");
			val.transform.SetParent(BlockObject.transform, false);
			RectTransform addBlock = val.RemoveOffset();
			var (val2, val3, _) = UIUtils.MakeButtonWithImage("Add Button", val, Vector2.zero, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), 80, 80, doOutline: false);
			val3.sprite = ScriptBlock.AddSprite;
			((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
			{
				if ((MaxChildren <= 0 || Children.Blocks.Count < MaxChildren) && ScriptManager.BlockTypes[ChildName]() is ChildBlock childBlock)
				{
					childBlock.Group = Children;
					ScriptManager.Blocks[childBlock.BlockId] = childBlock;
					childBlock.SetupBlock(newBlock: true);
					Children.Blocks.Add(childBlock);
					foreach (Architect.Events.Blocks.Config.Types.ConfigValue value in childBlock.CurrentConfig.Values)
					{
						value.Setup(childBlock);
					}
					if (Object.op_Implicit((Object)(object)childBlock.BlockObject))
					{
						childBlock.BlockObject.transform.SetParent(BlockObject.transform, true);
						Children.OrderChildren();
					}
				}
			});
			Children.AddBlock = addBlock;
			Children.MaxChildren = MaxChildren;
			Children.Height = height;
			Children.Parent = this;
			Children.NeedsGap = NeedsGap;
		}

		public override void Setup(bool visual, bool newBlock = false)
		{
			base.Setup(visual, newBlock);
			foreach (ChildBlock block in Children.Blocks)
			{
				ScriptManager.Blocks[block.BlockId] = block;
				block.Group = Children;
				if (visual && Object.op_Implicit((Object)(object)BlockObject))
				{
					block.SetupBlock(newBlock);
					if (!Object.op_Implicit((Object)(object)block.BlockObject))
					{
						return;
					}
					block.BlockObject.transform.SetParent(BlockObject.transform, true);
				}
				else
				{
					block.Reset();
				}
				foreach (Architect.Events.Blocks.Config.Types.ConfigValue value in block.CurrentConfig.Values)
				{
					value.Setup(block);
				}
			}
			if (visual)
			{
				Children.OrderChildren();
				return;
			}
			foreach (ChildBlock block2 in Children.Blocks)
			{
				block2.SetupReference();
			}
		}

		public override void Delete()
		{
			ChildBlock[] array = Children.Blocks.ToArray();
			foreach (ChildBlock childBlock in array)
			{
				childBlock.Delete();
			}
			base.Delete();
		}

		public override void LateSetup()
		{
			base.LateSetup();
			foreach (ChildBlock block in Children.Blocks)
			{
				block.LateSetup();
			}
		}

		public override void AddExtraIds(List<string> ids)
		{
			ids.AddRange(Children.Blocks.Select((ChildBlock child) => child.BlockId));
		}
	}
	public abstract class Deletable : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__2_0;

			internal void <Init>b__2_0()
			{
				if (Object.op_Implicit((Object)(object)_target))
				{
					_target.Delete();
					_target = null;
					DeleteButton.SetActive(false);
				}
			}
		}

		public static GameObject DeleteButton;

		private static Deletable _target;

		public static void Init(GameObject scriptUI)
		{
			//IL_0007: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			(Button, Image, UIUtils.Label) tuple = UIUtils.MakeButtonWithImage("Delete Button", scriptUI, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 96, 48, doOutline: false);
			Button item = tuple.Item1;
			Image item2 = tuple.Item2;
			DeleteButton = ((Component)item).gameObject;
			item2.sprite = ResourceUtils.LoadSpriteResource("delete_button", (FilterMode)1);
			ButtonClickedEvent onClick = item.onClick;
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					if (Object.op_Implicit((Object)(object)_target))
					{
						_target.Delete();
						_target = null;
						DeleteButton.SetActive(false);
					}
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
		}

		public abstract void Delete();

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if ((int)eventData.button != 1)
			{
				DeleteButton.SetActive(false);
				return;
			}
			_target = this;
			DeleteButton.SetActive(true);
			DeleteButton.transform.SetAsLastSibling();
			DeleteButton.transform.position = Vector2.op_Implicit(eventData.position + new Vector2(-20f, 20f));
		}
	}
	public abstract class LocalBlock : ScriptBlock
	{
		public bool Local;
	}
	[JsonConverter(typeof(ScriptBlockConverter))]
	public abstract class ScriptBlock
	{
		public class ScriptBlockInstance : Deletable, IDragHandler, IEventSystemHandler, IBeginDragHandler
		{
			public ScriptBlock Block;

			public Text text;

			public Image img;

			public ScriptBlockInstance overrideDrag;

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

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

			private Vector2 _offset;

			private bool _isGroupDragging;

			private List<(ScriptBlockInstance inst, Vector2 offset)> _groupOffsets;

			private Vector2 _groupStartMouse;

			private void Update()
			{
				//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)
				//IL_0066: 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)
				if (Object.op_Implicit((Object)(object)text))
				{
					text.text = Block.Name;
				}
				((Graphic)img).color = (ScriptManager.IsSelected(Block.BlockId) ? Color.Lerp(Block.Color, Settings.ScriptEditorBlockSelectedLerpColor.Value, 0.35f) : Block.Color);
			}

			public void OnDrag(PointerEventData eventData)
			{
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)overrideDrag))
				{
					overrideDrag.OnDrag(eventData);
					return;
				}
				if (_isGroupDragging && _groupOffsets != null)
				{
					foreach (var (scriptBlockInstance, val) in _groupOffsets)
					{
						if (Object.op_Implicit((Object)(object)scriptBlockInstance))
						{
							((Component)scriptBlockInstance).transform.position = Vector2.op_Implicit(eventData.position + val);
							if (scriptBlockInstance.Block != null)
							{
								scriptBlockInstance.Block.Position = Vector2.op_Implicit(((Component)scriptBlockInstance).transform.localPosition);
							}
						}
					}
					return;
				}
				((Component)this).transform.position = Vector2.op_Implicit(eventData.position + _offset);
				Block.Position = Vector2.op_Implicit(((Component)this).transform.localPosition);
			}

			public void OnBeginDrag(PointerEventData eventData)
			{
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: 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)
				if (Object.op_Implicit((Object)(object)overrideDrag))
				{
					overrideDrag.OnBeginDrag(eventData);
					return;
				}
				if (ScriptManager.IsSelected(Block.BlockId) && ScriptManager.SelectedBlockIds.Count > 1)
				{
					_isGroupDragging = true;
					_groupOffsets = new List<(ScriptBlockInstance, Vector2)>();
					_groupStartMouse = eventData.position;
					{
						foreach (string selectedBlockId in ScriptManager.SelectedBlockIds)
						{
							if (ScriptManager.Blocks.TryGetValue(selectedBlockId, out var value) && !((Object)(object)value?.BlockInstance == (Object)null))
							{
								ScriptBlockInstance blockInstance = value.BlockInstance;
								Vector2 item = Vector2.op_Implicit(((Component)blockInstance).transform.position) - _groupStartMouse;
								_groupOffsets.Add((blockInstance, item));
								((Component)blockInstance).transform.SetAsLastSibling();
							}
						}
						return;
					}
				}
				_offset = Vector2.op_Implicit(((Component)this).transform.position) - eventData.position;
				((Component)this).transform.SetAsLastSibling();
				_isGroupDragging = false;
				_groupOffsets = null;
			}

			public override void Delete()
			{
				if (!Extensions.IsNullOrEmpty<string>((ICollection<string>)ScriptManager.SelectedBlockIds))
				{
					string[] array = ScriptManager.SelectedBlockIds.ToArray();
					foreach (string key in array)
					{
						if (ScriptManager.Blocks.TryGetValue(key, out var value))
						{
							value.Delete();
						}
					}
					ScriptManager.SelectedBlockIds.Clear();
				}
				else
				{
					Block.Delete();
				}
			}
		}

		public class ScriptBlockConverter : JsonConverter<ScriptBlock>
		{
			public override void WriteJson(JsonWriter writer, ScriptBlock value, JsonSerializer serializer)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				writer.WriteStartObject();
				writer.WritePropertyName("pos");
				serializer.Serialize(writer, (object)value.Position);
				writer.WritePropertyName("block_id");
				writer.WriteValue(value.BlockId);
				writer.WritePropertyName("events");
				serializer.Serialize(writer, (object)value.EventMap);
				writer.WritePropertyName("vars");
				serializer.Serialize(writer, (object)value.VarMap);
				writer.WritePropertyName("type");
				writer.WriteValue(value.Type);
				if (value.CurrentConfig.Count > 0)
				{
					writer.WritePropertyName("config");
					serializer.Serialize(writer, (object)value.CurrentConfig.Values.ToDictionary((Architect.Events.Blocks.Config.Types.ConfigValue c) => c.GetTypeId(), (Architect.Events.Blocks.Config.Types.ConfigValue c) => c.SerializeValue()));
				}
				writer.WritePropertyName("ext");
				serializer.Serialize(writer, (object)value.SerializeExtraData());
				writer.WriteEndObject();
			}

			public override ScriptBlock ReadJson(JsonReader reader, Type objectType, ScriptBlock existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0238: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				//IL_023e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				string text = null;
				string blockId = null;
				Vector3 val = default(Vector3);
				Dictionary<string, List<(string, string)>> eventMap = new Dictionary<string, List<(string, string)>>();
				Dictionary<string, (string, string)> varMap = new Dictionary<string, (string, string)>();
				Dictionary<string, string> data = new Dictionary<string, string>();
				Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigValue> currentConfig = new Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigValue>();
				while (reader.Read() && reader.Value is string text2)
				{
					switch (text2)
					{
					case "type":
						reader.ReadAsString();
						text = reader.Value as string;
						break;
					case "block_id":
						reader.ReadAsString();
						blockId = reader.Value as string;
						break;
					case "pos":
						reader.Read();
						val = Vector2.op_Implicit(serializer.Deserialize<Vector2>(reader));
						break;
					case "events":
						reader.Read();
						eventMap = serializer.Deserialize<Dictionary<string, List<(string, string)>>>(reader);
						break;
					case "vars":
						reader.Read();
						varMap = serializer.Deserialize<Dictionary<string, (string, string)>>(reader);
						break;
					case "ext":
						reader.Read();
						data = serializer.Deserialize<Dictionary<string, string>>(reader);
						break;
					case "config":
						reader.Read();
						currentConfig = DeserializeConfig(serializer.Deserialize<Dictionary<string, string>>(reader));
						break;
					}
				}
				ScriptBlock scriptBlock = ((text == "object") ? new ObjectBlock() : ScriptManager.BlockTypes[text]());
				scriptBlock.DeserializeExtraData(data);
				scriptBlock.Type = text;
				scriptBlock.BlockId = blockId;
				scriptBlock.Position = Vector2.op_Implicit(val);
				scriptBlock.EventMap = eventMap;
				scriptBlock.VarMap = varMap;
				scriptBlock.CurrentConfig = currentConfig;
				return scriptBlock;
			}

			private static Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigValue> DeserializeConfig(Dictionary<string, string> data)
			{
				Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigValue> dictionary = new Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigValue>();
				foreach (KeyValuePair<string, string> datum in data)
				{
					dictionary[datum.Key] = Architect.Events.Blocks.Config.ConfigurationManager.DeserializeConfigValue(datum.Key, datum.Value);
				}
				return dictionary;
			}
		}

		public static readonly Sprite AddSprite = ResourceUtils.LoadSpriteResource("add", (FilterMode)0);

		protected static readonly ScriptBlockConverter Sbc = new ScriptBlockConverter();

		public static readonly (string, string) Space = ("", "");

		protected static readonly Sprite FlowchartBlock = ResourceUtils.LoadSpriteResource("Flowcharts.flowchart_block", (FilterMode)1, new Vector4(10f, 10f, 10f, 10f));

		private static readonly Sprite Input = ResourceUtils.LoadSpriteResource("Flowcharts.input", (FilterMode)0, default(Vector4), 15f);

		private static readonly Sprite Output = ResourceUtils.LoadSpriteResource("Flowcharts.output", (FilterMode)0, default(Vector4), 15f);

		public List<Architect.Events.Blocks.Config.Types.ConfigType> Config;

		public Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigValue> CurrentConfig = new Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigValue>();

		public Dictionary<string, List<(string, string)>> EventMap = new Dictionary<string, List<(string, string)>>();

		public Dictionary<string, (string, string)> VarMap = new Dictionary<string, (string, string)>();

		public string BlockId = Guid.NewGuid().ToString();

		public string Type;

		public Vector2 Position;

		[CanBeNull]
		public GameObject BlockObject;

		public ScriptBlockInstance BlockInstance;

		protected virtual IEnumerable<string> Inputs => Array.Empty<string>();

		protected virtual IEnumerable<string> Outputs => Array.Empty<string>();

		protected virtual IEnumerable<(string, string)> OutputVars => Array.Empty<(string, string)>();

		protected virtual IEnumerable<(string, string)> InputVars => Array.Empty<(string, string)>();

		protected virtual int InputCount => Inputs.Count();

		protected virtual int OutputCount => Outputs.Count();

		protected int InputVarCount => InputVars.Count();

		protected int OutputVarCount => OutputVars.Count();

		protected int ConfigCount => Config?.Count ?? 0;

		public virtual Color Color { get; set; }

		protected abstract string Name { get; }

		public virtual bool CanCloneDirectly => true;

		public virtual bool IsValid => true;

		public ScriptBlock Clone(string idAddition, bool trimStart = false)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			ScriptBlock scriptBlock = ScriptManager.BlockTypes[Type]();
			scriptBlock.Type = Type;
			scriptBlock.BlockId = (trimStart ? (idAddition + BlockId) : (BlockId + idAddition));
			scriptBlock.Position = Position;
			scriptBlock.EventMap = new Dictionary<string, List<(string, string)>>();
			string key;
			foreach (KeyValuePair<string, List<(string, string)>> item3 in EventMap)
			{
				item3.Deconstruct(out key, out var value);
				string key2 = key;
				List<(string, string)> list = value;
				List<(string, string)> list2 = new List<(string, string)>();
				foreach (var (text, item) in list)
				{
					list2.Add((trimStart ? (idAddition + text) : (text + idAddition), item));
				}
				scriptBlock.EventMap[key2] = list2;
			}
			scriptBlock.VarMap = new Dictionary<string, (string, string)>();
			foreach (KeyValuePair<string, (string, string)> item4 in VarMap)
			{
				item4.Deconstruct(out key, out var value2);
				(string, string) tuple2 = value2;
				string key3 = key;
				var (text2, item2) = tuple2;
				scriptBlock.VarMap[key3] = (trimStart ? (idAddition + text2) : (text2 + idAddition), item2);
			}
			Architect.Events.Blocks.Config.Types.ConfigValue value3;
			foreach (KeyValuePair<string, Architect.Events.Blocks.Config.Types.ConfigValue> item5 in CurrentConfig)
			{
				item5.Deconstruct(out key, out value3);
				Architect.Events.Blocks.Config.Types.ConfigValue configValue = value3;
				configValue.Setup(this);
			}
			foreach (KeyValuePair<string, Architect.Events.Blocks.Config.Types.ConfigValue> item6 in CurrentConfig)
			{
				item6.Deconstruct(out key, out value3);
				string key4 = key;
				Architect.Events.Blocks.Config.Types.ConfigValue configValue2 = value3;
				Architect.Events.Blocks.Config.Types.ConfigValue value4 = ((trimStart || !(this is LocalBlock localBlock) || !localBlock.Local || !configValue2.IsLocal) ? configValue2 : Architect.Events.Blocks.Config.ConfigurationManager.DeserializeConfigValue(configValue2.GetTypeId(), configValue2.SerializeValue() + idAddition));
				scriptBlock.CurrentConfig[key4] = value4;
			}
			Dictionary<string, string> dictionary = SerializeExtraData();
			if (!trimStart && dictionary.ContainsKey("object"))
			{
				dictionary["object"] += idAddition;
			}
			if (dictionary.ContainsKey("children"))
			{
				List<ScriptBlock> list3 = JsonConvert.DeserializeObject<List<ScriptBlock>>(dictionary["children"], (JsonConverter[])(object)new JsonConverter[1] { (JsonConverter)Sbc });
				for (int i = 0; i < list3.Count; i++)
				{
					list3[i] = list3[i].Clone(idAddition, trimStart);
				}
				dictionary["children"] = JsonConvert.SerializeObject((object)list3);
			}
			scriptBlock.DeserializeExtraData(dictionary);
			return scriptBlock;
		}

		public virtual void Setup(bool visual, bool newBlock = false)
		{
			ScriptManager.Blocks[BlockId] = this;
			if (visual)
			{
				SetupBlock(newBlock);
				{
					foreach (Architect.Events.Blocks.Config.Types.ConfigValue value in CurrentConfig.Values)
					{
						value.Setup(this);
					}
					return;
				}
			}
			Reset();
			foreach (Architect.Events.Blocks.Config.Types.ConfigValue value2 in CurrentConfig.Values)
			{
				value2.Setup(this);
			}
			SetupReference();
		}

		public virtual void LateSetup()
		{
			if (!EditManager.IsEditing || !IsValid)
			{
				return;
			}
			string key;
			foreach (KeyValuePair<string, List<(string, string)>> item in EventMap)
			{
				item.Deconstruct(out key, out var value);
				string sourceEvent = key;
				List<(string, string)> list = value;
				(string, string)[] array = list.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					var (text, text2) = array[i];
					if (!ScriptManager.Blocks.TryGetValue(text, out var value2) || !value2.IsValid || !value2.Inputs.Contains(text2))
					{
						list.Remove((text, text2));
					}
					else
					{
						ScriptManager.MakeLink(this, sourceEvent, value2, text2, ScriptManager.Connection.LinkType.Event);
					}
				}
			}
			KeyValuePair<string, (string, string)>[] array2 = VarMap.ToArray();
			foreach (KeyValuePair<string, (string, string)> keyValuePair in array2)
			{
				keyValuePair.Deconstruct(out key, out var value3);
				(string, string) tuple2 = value3;
				string source = key;
				var (key2, trigger) = tuple2;
				if (!ScriptManager.Blocks.TryGetValue(key2, out var value4) || !value4.IsValid || InputVars.All(((string, string) o) => o.Item1 != source))
				{
					VarMap.Remove(source);
				}
				else
				{
					ScriptManager.MakeLink(this, source, value4, trigger, ScriptManager.Connection.LinkType.Var);
				}
			}
		}

		public T GetVariable<T>(string id, object def = null)
		{
			object obj;
			if (!VarMap.TryGetValue(id, out var value))
			{
				obj = def ?? GetDefaultValue<T>();
			}
			else
			{
				(string, string) tuple = value;
				string item = tuple.Item1;
				string item2 = tuple.Item2;
				obj = (ScriptManager.Blocks.TryGetValue(item, out var value2) ? (value2.GetValue(item2) ?? def ?? GetDefaultValue<T>()) : (def ?? GetDefaultValue<T>()));
			}
			if (typeof(T) == typeof(float) && obj is int num)
			{
				return (T)(object)(float)num;
			}
			if (typeof(T) == typeof(GameObject))
			{
				HealthManager val = (HealthManager)((obj is HealthManager) ? obj : null);
				if (val != null && Object.op_Implicit((Object)(object)val))
				{
					return (T)(object)((Component)val).gameObject;
				}
			}
			if (typeof(T) == typeof(HealthManager))
			{
				GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
				if (val2 != null)
				{
					if (Object.op_Implicit((Object)(object)val2))
					{
						return (T)(object)val2.GetComponentInChildren<HealthManager>();
					}
					obj = GetDefaultValue<T>();
				}
			}
			return (T)obj;
		}

		private static object GetDefaultValue<T>()
		{
			Type typeFromHandle = typeof(T);
			if (typeFromHandle == typeof(bool))
			{
				return false;
			}
			if (typeFromHandle == typeof(int) || typeFromHandle == typeof(float))
			{
				return 0;
			}
			return null;
		}

		[CanBeNull]
		public virtual object GetValue(string id)
		{
			return null;
		}

		public void SetupBlock(bool newBlock)
		{
			int height = 50 * (1 + Math.Max(ConfigCount / 2, Math.Max(InputCount, OutputCount)));
			int width = 50 * Math.Max(5, 1 + Math.Max(OutputVarCount, InputVarCount));
			SetupBlock(newBlock, width, height);
		}

		protected virtual void SetupBlock(bool newBlock, int width, int height)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Unknown result type (might be due to invalid IL or missing references)
			//IL_066f: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			//IL_068d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_070d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_0737: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Expected O, but got Unknown
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0803: Unknown result type (might be due to invalid IL or missing references)
			//IL_0812: Unknown result type (might be due to invalid IL or missing references)
			//IL_0830: Unknown result type (might be due to invalid IL or missing references)
			//IL_083f: Unknown result type (might be due to invalid IL or missing references)
			//IL_084e: Unknown result type (might be due to invalid IL or missing references)
			//IL_089e: Unknown result type (might be due to invalid IL or missing references)
			//IL_097f: Unknown result type (might be due to invalid IL or missing references)
			//IL_098e: Unknown result type (might be due to invalid IL or missing references)
			//IL_099d: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aac: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)BlockObject))
			{
				Object.Destroy((Object)(object)BlockObject);
			}
			int num = (width - 250) / 2;
			Image val = UIUtils.MakeImage("Script Block", ScriptEditorUI.Blocks, Position, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2((float)width, (float)height));
			BlockObject = ((Component)val).gameObject;
			val.sprite = FlowchartBlock;
			val.type = (Type)1;
			((Graphic)val).color = Color;
			BlockInstance = BlockObject.AddComponent<ScriptBlockInstance>();
			BlockInstance.img = val;
			BlockInstance.Block = this;
			if (Name != null)
			{
				UIUtils.Label label = UIUtils.MakeLabel(Name, BlockObject, new Vector2(10f, (float)height / 2f + 15f), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), 80f, 80f, (HorizontalWrapMode)1);
				((RectTransform)((Component)label).transform).pivot = new Vector2(0f, 0.5f);
				((Text)label.textComponent).fontSize = 20;
				((Text)label.textComponent).alignment = (TextAnchor)3;
				BlockInstance.text = (Text)(object)label.textComponent;
			}
			if (Config != null)
			{
				int num2 = 0;
				GameObject val2 = new GameObject("Config");
				val2.transform.parent = BlockObject.transform;
				val2.transform.localScale = new Vector3(1.8f, 1.8f);
				GameObject val3 = val2;
				RectTransform val4 = val3.AddComponent<RectTransform>();
				val4.anchorMax = Vector2.one;
				val4.anchorMin = new Vector2(0f, 1f);
				val4.offsetMax = Vector2.zero;
				val4.offsetMin = Vector2.zero;
				foreach (Architect.Events.Blocks.Config.Types.ConfigType item in Config)
				{
					Architect.Events.Blocks.Config.Types.ConfigType type = item;
					Button btn;
					Architect.Events.Blocks.Config.Types.ConfigElement inp;
					if (!type.PrefabOnly || PrefabManager.InPrefabScene)
					{
						Image val5 = UIUtils.MakeImage("Image", val3, new Vector2(0f, (float)num2), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(250f, 25f));
						((Graphic)val5).color = new Color(0f, 0f, 0f, 0.5f);
						val5.sprite = UIUtils.Square;
						UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Config Title", val3, Vector2.op_Implicit(new Vector3((float)(105 + num), (float)num2)), Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1).textComponent;
						((Text)textComponent).text = type.Name;
						((Text)textComponent).fontSize = 8;
						((Text)textComponent).alignment = (TextAnchor)3;
						(btn, _) = UIUtils.MakeTextButton("Config Apply", "Apply", val3, Vector2.op_Implicit(new Vector3((float)(175 + num), (float)num2)), Vector2.zero, Vector2.zero);
						((Selectable)btn).interactable = false;
						if (newBlock && type.GetDefaultValue() != null)
						{
							CurrentConfig[type.Id] = type.GetDefaultValue();
						}
						inp = type.CreateInput(val3, btn, new Vector3((float)(130 + num), (float)num2), CurrentConfig.GetValueOrDefault(type.Id)?.SerializeValue());
						((UnityEvent)btn.onClick).AddListener(new UnityAction(Apply));
						((Component)val5).transform.SetAsFirstSibling();
						num2 -= 14;
					}
					void Apply()
					{
						((Selectable)btn).interactable = false;
						string value = inp.GetValue();
						if (value.Length == 0)
						{
							CurrentConfig.Remove(type.Id);
						}
						else
						{
							CurrentConfig[type.Id] = type.Deserialize(inp.GetValue());
						}
					}
				}
				val4.anchoredPosition = new Vector2(0f, -25f);
			}
			int num3 = 0;
			foreach (string input in Inputs)
			{
				num3++;
				Image val6 = UIUtils.MakeImage("Input", BlockObject, new Vector2(0f, (float)(num3 * -50)), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(40f, 40f));
				UIUtils.Label label2 = UIUtils.MakeLabel(input, BlockObject, new Vector2(-55f, (float)(num3 * -50)), new Vector2(0f, 1f), new Vector2(0f, 1f), 80f, 80f, (HorizontalWrapMode)1);
				((Text)label2.textComponent).text = ((this is ObjectBlock) ? (EventManager.GetReceiverType(input)?.Name ?? input) : input);
				((Text)label2.textComponent).alignment = (TextAnchor)5;
				val6.sprite = Input;
				((Graphic)val6).color = Color;
				ScriptManager.EventEnd eventEnd = ((Component)val6).gameObject.AddComponent<ScriptManager.EventEnd>();
				eventEnd.id = input;
				eventEnd.Block = this;
				BlockInstance.LinkEnds[eventEnd.id] = ((Component)eventEnd).transform;
			}
			num3 = 0;
			foreach (string output in Outputs)
			{
				num3++;
				Image val7 = UIUtils.MakeImage("Output", BlockObject, new Vector2(0f, (float)(num3 * -50)), new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(40f, 40f));
				UIUtils.Label label3 = UIUtils.MakeLabel(output, BlockObject, new Vector2(55f, (float)(num3 * -50)), new Vector2(1f, 1f), new Vector2(1f, 1f), 80f, 80f, (HorizontalWrapMode)1);
				((Text)label3.textComponent).text = output;
				((Text)label3.textComponent).alignment = (TextAnchor)3;
				val7.sprite = Output;
				((Graphic)val7).color = Color;
				ScriptManager.EventStart eventStart = ((Component)val7).gameObject.AddComponent<ScriptManager.EventStart>();
				eventStart.img = val7;
				eventStart.color = Color;
				eventStart.id = output;
				eventStart.Block = this;
				BlockInstance.LinkStarts[eventStart.id] = ((Component)eventStart).transform;
			}
			num3 = InputVarCount;
			foreach (var (text, text2) in InputVars)
			{
				if (Utility.IsNullOrWhiteSpace(text2))
				{
					num3--;
					continue;
				}
				Image val8 = UIUtils.MakeImage("Input Var", BlockObject, new Vector2((float)(num3 * -50), 0f), new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(40f, 40f));
				UIUtils.Label label4 = UIUtils.MakeLabel(text, BlockObject, new Vector2((float)(num3 * -50), 45f), new Vector2(1f, 1f), new Vector2(1f, 1f), 80f, 80f, (HorizontalWrapMode)1);
				((Text)label4.textComponent).text = text + "\n" + text2;
				((Text)label4.textComponent).alignment = (TextAnchor)4;
				val8.sprite = Input;
				((Graphic)val8).color = Color;
				Extensions.SetRotation2D(((Component)val8).transform, 270f);
				num3--;
				ScriptManager.VarEnd varEnd = ((Component)val8).gameObject.AddComponent<ScriptManager.VarEnd>();
				varEnd.id = text;
				varEnd.type = text2;
				varEnd.Block = this;
				BlockInstance.LinkStarts[varEnd.id] = ((Component)varEnd).transform;
			}
			num3 = OutputVarCount;
			foreach (var (text3, text4) in OutputVars)
			{
				if (Utility.IsNullOrWhiteSpace(text4))
				{
					num3--;
					continue;
				}
				Image val9 = UIUtils.MakeImage("Output Var", BlockObject, new Vector2((float)(num3 * -50), 0f), new Vector2(1f, 0f), new Vector2(1f, 0f), new Vector2(40f, 40f));
				UIUtils.Label label5 = UIUtils.MakeLabel(text3, BlockObject, new Vector2((float)(num3 * -50), -45f), new Vector2(1f, 0f), new Vector2(1f, 0f), 80f, 80f, (HorizontalWrapMode)1);
				((Text)label5.textComponent).text = ((!(this is ObjectBlock)) ? text3 : (EventManager.GetOutputType(text3)?.Name ?? text3)) + "\n" + text4;
				((Text)label5.textComponent).alignment = (TextAnchor)4;
				val9.sprite = Output;
				((Graphic)val9).color = Color;
				Extensions.SetRotation2D(((Component)val9).transform, 270f);
				num3--;
				ScriptManager.VarStart varStart = ((Component)val9).gameObject.AddComponent<ScriptManager.VarStart>();
				varStart.id = text3;
				varStart.Block = this;
				varStart.img = val9;
				varStart.color = Color;
				varStart.type = text4;
				BlockInstance.LinkEnds[varStart.id] = ((Component)varStart).transform;
			}
		}

		protected virtual Dictionary<string, string> SerializeExtraData()
		{
			return new Dictionary<string, string>();
		}

		protected virtual void DeserializeExtraData(Dictionary<string, string> data)
		{
		}

		public virtual void SetupReference()
		{
		}

		public virtual void Reset()
		{
		}

		public virtual void Event(string name)
		{
			if (EditManager.IsEditing || !EventMap.TryGetValue(name, out var value))
			{
				return;
			}
			(string, string)[] array = value.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				var (key, trigger) = array[i];
				if (ScriptManager.Blocks.TryGetValue(key, out var value2) && value2.IsValid)
				{
					value2.Trigger(trigger);
				}
			}
		}

		protected virtual void Trigger(string trigger)
		{
		}

		public void DestroyObject()
		{
			if (Object.op_Implicit((Object)(object)BlockObject))
			{
				Object.Destroy((Object)(object)BlockObject);
			}
		}

		public virtual void Delete()
		{
			if (!Object.op_Implicit((Object)(object)BlockObject))
			{
				return;
			}
			string key;
			List<(string, string)> value;
			foreach (KeyValuePair<string, List<(string, string)>> item2 in EventMap)
			{
				item2.Deconstruct(out key, out value);
				string sourceEvent = key;
				List<(string, string)> list = value;
				(string, string)[] array = list.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					var (block, trigger) = array[i];
					ScriptManager.DestroyLink(BlockId, sourceEvent, block, trigger, ScriptManager.Connection.LinkType.Event);
				}
			}
			KeyValuePair<string, (string, string)>[] array2 = VarMap.ToArray();
			(string, string) value2;
			foreach (KeyValuePair<string, (string, string)> keyValuePair in array2)
			{
				keyValuePair.Deconstruct(out key, out value2);
				(string, string) tuple2 = value2;
				string sourceEvent2 = key;
				var (block2, trigger2) = tuple2;
				ScriptManager.DestroyLink(BlockId, sourceEvent2, block2, trigger2, ScriptManager.Connection.LinkType.Var);
			}
			foreach (ScriptBlock value3 in ScriptManager.Blocks.Values)
			{
				foreach (KeyValuePair<string, List<(string, string)>> item3 in value3.EventMap)
				{
					item3.Deconstruct(out key, out value);
					string sourceEvent3 = key;
					List<(string, string)> source = value;
					(string, string)[] array3 = source.Where(((string, string) o) => o.Item1 == BlockId).ToArray();
					for (int k = 0; k < array3.Length; k++)
					{
						string item = array3[k].Item2;
						ScriptManager.DestroyLink(value3.BlockId, sourceEvent3, BlockId, item, ScriptManager.Connection.LinkType.Event);
					}
				}
				KeyValuePair<string, (string, string)>[] array4 = value3.VarMap.ToArray();
				foreach (KeyValuePair<string, (string, string)> keyValuePair in array4)
				{
					keyValuePair.Deconstruct(out key, out value2);
					(string, string) tuple4 = value2;
					string sourceEvent4 = key;
					var (text, trigger3) = tuple4;
					if (!(text != BlockId))
					{
						ScriptManager.DestroyLink(value3.BlockId, sourceEvent4, BlockId, trigger3, ScriptManager.Connection.LinkType.Var);
					}
				}
			}
			ScriptManager.Blocks.Remove(BlockId);
			PlacementManager.GetLevelData().ScriptBlocks.Remove(this);
			PlacementManager.GetGlobalData().ScriptBlocks.Remove(this);
			Object.Destroy((Object)(object)BlockObject);
		}
	}
	public static class ScriptManager
	{
		public class Start : MonoBehaviour
		{
			public Image img;

			public Color color;

			public ScriptBlock Block;

			public string id;
		}

		public class EventStart : Start, IPointerDownHandler, IEventSystemHandler
		{
			public void OnPointerDown(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				if ((int)eventData.button > 0 || !Block.IsValid)
				{
					return;
				}
				if (Object.op_Implicit((Object)(object)CurrentStart))
				{
					((Graphic)CurrentStart.img).color = CurrentStart.color;
					if ((Object)(object)CurrentStart == (Object)(object)this)
					{
						CurrentStart = null;
						return;
					}
					if (InSwapMode)
					{
						(string, string)[] array = CurrentStart.Block.EventMap[CurrentStart.id].ToArray();
						for (int i = 0; i < array.Length; i++)
						{
							(string, string) tuple = array[i];
							if (!Input.GetKey((KeyCode)308))
							{
								DestroyLink(CurrentStart.Block.BlockId, CurrentStart.id, tuple.Item1, tuple.Item2, Connection.LinkType.Event);
							}
							Dictionary<string, List<(string, string)>> eventMap = Block.EventMap;
							if (!eventMap.ContainsKey(id))
							{
								eventMap[id] = new List<(string, string)>();
							}
							if (!eventMap[id].Contains((tuple.Item1, tuple.Item2)))
							{
								eventMap[id].Add((tuple.Item1, tuple.Item2));
								MakeLink(Block, id, Blocks[tuple.Item1], tuple.Item2, Connection.LinkType.Event);
							}
						}
						CurrentStart = null;
						return;
					}
					CurrentStart = null;
				}
				CurrentStart = this;
				InSwapMode = Input.GetKey((KeyCode)308);
				((Graphic)img).color = (InSwapMode ? Orange : Color.cyan);
			}
		}

		public class EventEnd : MonoBehaviour, IPointerDownHandler, IEventSystemHandler
		{
			public ScriptBlock Block;

			public string id;

			public void OnPointerDown(PointerEventData eventData)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if (!(CurrentStart is EventStart) || InSwapMode)
				{
					return;
				}
				((Graphic)CurrentStart.img).color = CurrentStart.color;
				if (Block.IsValid && CurrentStart.Block.IsValid)
				{
					Dictionary<string, List<(string, string)>> eventMap = CurrentStart.Block.EventMap;
					if (!eventMap.ContainsKey(CurrentStart.id))
					{
						eventMap[CurrentStart.id] = new List<(string, string)>();
					}
					if (!eventMap[CurrentStart.id].Contains((Block.BlockId, id)))
					{
						eventMap[CurrentStart.id].Add((Block.BlockId, id));
						MakeLink(CurrentStart.Block, CurrentStart.id, Block, id, Connection.LinkType.Event);
						CurrentStart = null;
					}
				}
			}
		}

		public class VarStart : Start, IPointerDownHandler, IEventSystemHandler
		{
			public string type;

			public void OnPointerDown(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_007e: 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)
				if ((int)eventData.button > 0 || !Block.IsValid)
				{
					return;
				}
				if (Object.op_Implicit((Object)(object)CurrentStart))
				{
					((Graphic)CurrentStart.img).color = CurrentStart.color;
					if ((Object)(object)CurrentStart == (Object)(object)this)
					{
						CurrentStart = null;
						return;
					}
					CurrentStart = null;
				}
				CurrentStart = this;
				InSwapMode = false;
				((Graphic)img).color = Color.cyan;
			}
		}

		public class VarEnd : MonoBehaviour, IPointerDownHandler, IEventSystemHandler
		{
			public ScriptBlock Block;

			public string id;

			public string type;

			public void OnPointerDown(PointerEventData eventData)
			{
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				if (CurrentStart is VarStart varStart && (!(varStart.type != type) || !(type != "Any") || (varStart.type == "Enemy" && type == "Object") || (varStart.type == "Object" && type == "Enemy")) && Block.IsValid && CurrentStart.Block.IsValid)
				{
					Dictionary<string, (string, string)> varMap = Block.VarMap;
					if (!varMap.ContainsKey(id))
					{
						((Graphic)CurrentStart.img).color = CurrentStart.color;
						varMap[id] = (CurrentStart.Block.BlockId, CurrentStart.id);
						MakeLink(Block, id, CurrentStart.Block, CurrentStart.id, Connection.LinkType.Var);
						CurrentStart = null;
					}
				}
			}
		}

		public class Connection : Deletable, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
		{
			public enum LinkType
			{
				Event,
				Var
			}

			public RectTransform t1;

			public RectTransform t2;

			public Image img;

			public string sourceBlock;

			public string targetBlock;

			public string sourceEvent;

			public string trigger;

			public LinkType linkType;

			public void Update()
			{
				//IL_002e: 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_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)t1) && Object.op_Implicit((Object)(object)t2))
				{
					Vector3 position = (((Transform)t1).position + ((Transform)t2).position) / 2f;
					((Component)this).transform.position = position;
					Vector3 val = ((Transform)t1).position - ((Transform)t2).position;
					((Component)this).transform.rotation = Quaternion.Euler(0f, 0f, Mathf.Atan2(val.y, val.x) * 57.29578f);
					((Component)this).transform.localScale = new Vector3(((Vector3)(ref val)).magnitude / ((Component)this).transform.parent.lossyScale.x - t1.sizeDelta.x / 2f, 1f, 1f);
				}
			}

			public override void Delete()
			{
				DestroyLink(sourceBlock, sourceEvent, targetBlock, trigger, linkType);
			}

			public void OnPointerEnter(PointerEventData eventData)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)img).color = Color.cyan;
			}

			public void OnPointerExit(PointerEventData eventData)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)img).color = Color.white;
			}
		}

		private static bool _local;

		public static Start CurrentStart;

		public static bool InSwapMode;

		public static readonly Dictionary<string, Func<ScriptBlock>> BlockTypes = new Dictionary<string, Func<ScriptBlock>>();

		public static Category CurrentCategory = Category.All;

		public static string Filter = string.Empty;

		public static readonly Dictionary<string, ScriptBlock> Blocks = new Dictionary<string, ScriptBlock>();

		public static readonly Dictionary<(string, string, string, string), GameObject> Links = new Dictionary<(string, string, string, string), GameObject>();

		public static readonly HashSet<string> SelectedBlockIds = new HashSet<string>();

		private static readonly Color Orange = new Color(0.9f, 0.7f, 0f);

		public static bool IsLocal
		{
			get
			{
				return _local;
			}
			set
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				_local = value;
				ScriptEditorUI.LocalParent.SetActive(value);
				ScriptEditorUI.GlobalParent.SetActive(!value);
				if (Object.op_Implicit((Object)(object)CurrentStart))
				{
					((Graphic)CurrentStart.img).color = CurrentStart.color;
					CurrentStart = null;
					InSwapMode = false;
				}
			}
		}

		public static IEnumerable<(Func<ScriptBlock>, string)> CurrentBlocks => CurrentCategory.Blocks.Where(((Func<ScriptBlock>, string) c) => c.Item2.Contains(Filter, StringComparison.InvariantCultureIgnoreCase));

		public static Vector3 BlockSpawnPos => ScriptEditorUI.Blocks.transform.InverseTransformPoint((float)Screen.width / 2f, (float)Screen.height / 2f, 0f);

		public static void Init()
		{
			EventBlocks.Init();
			ActionBlocks.Init();
			OperatorBlocks.Init();
			foreach (Category category in Category.Categories)
			{
				Category.All.Blocks.AddRange(category.Blocks);
			}
			FunctionManager.Init();
			BlockTypes["object"] = () => new ObjectBlock
			{
				Type = "object"
			};
		}

		public static void ClearSelection()
		{
			SelectedBlockIds.Clear();
		}

		public static void SetSelection(IEnumerable<string> ids)
		{
			SelectedBlockIds.Clear();
			foreach (string id in ids)
			{
				SelectedBlockIds.Add(id);
			}
		}

		public static bool IsSelected(string blockId)
		{
			return SelectedBlockIds.Contains(blockId);
		}

		public static void MakeLink(ScriptBlock sourceBlock, string sourceEvent, ScriptBlock block, string trigger, Connection.LinkType linkType)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00b0: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (!sourceBlock.BlockInstance.LinkStarts.TryGetValue(sourceEvent, out var value))
			{
				return;
			}
			RectTransform val = (RectTransform)value;
			if (block.BlockInstance.LinkEnds.TryGetValue(trigger, out var value2))
			{
				RectTransform val2 = (RectTransform)value2;
				if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val2))
				{
					Dictionary<(string, string, string, string), GameObject> links = Links;
					(string, string, string, string) key = (sourceBlock.BlockId, sourceEvent, block.BlockId, trigger);
					GameObject val3 = new GameObject("Link");
					val3.transform.parent = ScriptEditorUI.Lines.transform;
					GameObject val4 = val3;
					links[key] = val3;
					GameObject val5 = val4;
					val5.AddComponent<RectTransform>().sizeDelta = new Vector2(1f, 4f);
					Connection connection = val5.AddComponent<Connection>();
					connection.linkType = linkType;
					connection.t1 = val;
					connection.t2 = val2;
					connection.sourceBlock = sourceBlock.BlockId;
					connection.sourceEvent = sourceEvent;
					connection.targetBlock = block.BlockId;
					connection.trigger = trigger;
					Image val6 = val5.AddComponent<Image>();
					val6.sprite = UIUtils.Square;
					connection.img = val6;
				}
			}
		}

		public static void DestroyLink(string sourceBlock, string sourceEvent, string block, string trigger, Connection.LinkType linkType)
		{
			if (Links.ContainsKey((sourceBlock, sourceEvent, block, trigger)) && Links.Remove((sourceBlock, sourceEvent, block, trigger), out var value))
			{
				if (linkType == Connection.LinkType.Event)
				{
					Dictionary<string, List<(string, string)>> eventMap = Blocks[sourceBlock].EventMap;
					eventMap[sourceEvent].Remove((block, trigger));
				}
				else
				{
					Blocks[sourceBlock].VarMap.Remove(sourceEvent);
				}
				Object.Destroy((Object)(object)value);
			}
		}

		public static void AddToScript(ObjectPlacement obj)
		{
			//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_0083: Unknown result type (might be due to invalid IL or missing references)
			bool isLocal = IsLocal;
			if (!isLocal)
			{
				IsLocal = true;
			}
			((Text)EditorUI.ObjectIdLabel.textComponent).text = obj.GetPlacementType().GetName() + " added";
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(CursorObject.ClearCursorInfoLabel());
			ObjectBlock objectBlock = new ObjectBlock
			{
				TypeId = obj.GetPlacementType().GetId(),
				TargetId = obj.GetId(),
				Type = "object",
				Position = Vector2.op_Implicit(BlockSpawnPos)
			};
			objectBlock.Setup(visual: true);
			PlacementManager.GetLevelData().ScriptBlocks.Add(objectBlock);
			if (!isLocal)
			{
				IsLocal = false;
			}
		}
	}
}
namespace Architect.Events.Blocks.Outputs
{
	public class AchievementBlock : ScriptBlock
	{
		public string AchievementName;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Complete");

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Completed", "Boolean"));

		protected override string Name => "Achievement Control";

		public override void Reset()
		{
			AchievementName = "";
		}

		protected override void Trigger(string trigger)
		{
			GameSettings gameSettings = GameManager.instance.gameSettings;
			int showNativeAchievementPopups = gameSettings.showNativeAchievementPopups;
			gameSettings.showNativeAchievementPopups = 1;
			GameManager.instance.achievementHandler.AwardAchievementToPlayer(AchievementName);
			gameSettings.showNativeAchievementPopups = showNativeAchievementPopups;
		}

		public override object GetValue(string id)
		{
			return GameManager.instance.achievementHandler.AchievementWasAwarded(AchievementName);
		}
	}
	public static class ActionBlocks
	{
		public static void Init()
		{
			Category.World.RegisterBlock<HpBlock>("Health Control", Architect.Events.Blocks.Config.ConfigGroup.HealthHook);
			Category.World.RegisterBlock<InvulBlock>("Invulnerable Control", Architect.Events.Blocks.Config.ConfigGroup.InvulHook, InvulBlock.Init);
			Category.World.RegisterBlock<SilkBlock>("Silk Control", Architect.Events.Blocks.Config.ConfigGroup.SilkHook, SilkBlock.Init);
			Category.World.RegisterBlock<CurrencyBlock>("Currency Control", Architect.Events.Blocks.Config.ConfigGroup.CurrencyHook);
			Category.World.RegisterBlock<StatusBlock>("Status Control");
			Category.World.RegisterBlock<QuestBlock>("Quest Control", Architect.Events.Blocks.Config.ConfigGroup.QuestControl);
			Category.World.RegisterBlock<JournalEntryBlock>("Journal Control", Architect.Events.Blocks.Config.ConfigGroup.EntryControl);
			Category.World.RegisterBlock<AchievementBlock>("Achievement Control", Architect.Events.Blocks.Config.ConfigGroup.AchievementControl);
			Category.World.RegisterBlock<ToolBlock>("Tool Control", Architect.Events.Blocks.Config.ConfigGroup.ToolControl);
			Category.World.RegisterBlock<CrestBlock>("Crest Control", Architect.Events.Blocks.Config.ConfigGroup.CrestControl, CrestBlock.Init);
			Category.World.RegisterBlock<ItemBlock>("Item Control", Architect.Events.Blocks.Config.ConfigGroup.ItemControl);
			Category.World.RegisterBlock<EnemyBlock>("Enemy Control", Architect.Events.Blocks.Config.ConfigGroup.EnemyControl);
			Category.Visual.RegisterBlock<TextBlock>("Text Display", Architect.Events.Blocks.Config.ConfigGroup.TextDisplay);
			Category.Visual.RegisterBlock<ChoiceBlock>("Choice Display", Architect.Events.Blocks.Config.ConfigGroup.ChoiceDisplay);
			Category.Visual.RegisterBlock<TitleBlock>("Title Display", Architect.Events.Blocks.Config.ConfigGroup.TitleDisplay);
			Category.Visual.RegisterBlock<SongBlock>("Song Display", Architect.Events.Blocks.Config.ConfigGroup.SongDisplay);
			Category.Visual.RegisterBlock<PngBlock>("Custom PNG", Architect.Events.Blocks.Config.ConfigGroup.Png);
			Category.Visual.RegisterBlock<PowerupGetBlock>("Powerup Display", Architect.Events.Blocks.Config.ConfigGroup.PowerupDisplay, PowerupGetBlock.Init);
			Category.Visual.RegisterBlock<ShakeCameraBlock>("Camera Shake", Architect.Events.Blocks.Config.ConfigGroup.CameraShaker);
			Category.Visual.RegisterBlock<UIBlock>("UI Control", Architect.Events.Blocks.Config.ConfigGroup.UIControl);
			Category.Visual.RegisterBlock<TimeSlowerBlock>("Time Slowdown", Architect.Events.Blocks.Config.ConfigGroup.TimeSlower, TimeSlowerBlock.Init);
			Category.Visual.RegisterBlock<AnimatorBlock>("Animator Controller", Architect.Events.Blocks.Config.ConfigGroup.AnimPlayer);
			Category.World.RegisterBlock<TransitionBlock>("Transition", Architect.Events.Blocks.Config.ConfigGroup.Transition);
			Category.Visual.RegisterBlock<SetLightingBlock>("Set Lighting", Architect.Events.Blocks.Config.ConfigGroup.Lighting, SetLightingBlock.Init);
			Category.World.RegisterBlock<SpawnObjectBlock>("Spawn Object", Architect.Events.Blocks.Config.ConfigGroup.SpawnObject);
			Category.World.RegisterBlock<SpawnPrefabBlock>("Spawn Prefab", Architect.Events.Blocks.Config.ConfigGroup.Prefab);
			Category.World.RegisterBlock<ObjectMoverBlock>("Move Object");
			Category.Visual.RegisterBlock<TravelBlock>("Travel UI", Architect.Events.Blocks.Config.ConfigGroup.TravelUI, TravelBlock.Init);
			Category.Visual.RegisterHiddenBlock<TravelBlock.TravelLoc>("Travel Target", Architect.Events.Blocks.Config.ConfigGroup.TravelUITarget);
			Category.Visual.RegisterBlock<ShopBlock>("Shop", null, ShopBlock.Init);
			Category.Visual.RegisterHiddenBlock<ShopBlock.ShopItemBlock>("Shop Item", Architect.Events.Blocks.Config.ConfigGroup.ShopItem);
			Category.Visual.RegisterBlock<QuestboardBlock>("Quest Board", null, QuestboardBlock.Init);
			Category.Visual.RegisterHiddenBlock<QuestboardBlock.QuestBlock>("Quest Item", Architect.Events.Blocks.Config.ConfigGroup.QuestItem);
			LegacyTravelBlock.Init();
			Category.Visual.RegisterHiddenBlock<LegacyTravelBlock>("Travel List", Architect.Events.Blocks.Config.ConfigGroup.TravelList);
			Category.Visual.RegisterHiddenBlock<TravelLoc>("Travel", Architect.Events.Blocks.Config.ConfigGroup.Travel);
		}
	}
	public class AnimatorBlock : ScriptBlock
	{
		public string ClipName;

		public bool TakeCtrl;

		public bool ClearXVel = true;

		public bool ClearYVel = false;

		public bool OverrideAnimTime;

		public float AnimTime;

		private IAnimPlayer _player;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Start", "Stop" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Stop");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Target", "Object"));

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Current", "Text"));

		protected override string Name => "Animator Controller";

		public override void SetupReference()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			GameObject variable = GetVariable<GameObject>("Target");
			if (Object.op_Implicit((Object)(object)variable) && (Object)(object)variable != (Object)(object)((Component)HeroController.instance).gameObject)
			{
				AnimPlayer animPlayer = variable.AddComponent<AnimPlayer>();
				animPlayer.animator = variable.GetComponent<tk2dSpriteAnimator>();
				if (Object.op_Implicit((Object)(object)animPlayer.animator))
				{
					animPlayer.clip = animPlayer.animator.GetClipByName(ClipName);
					animPlayer.overrideAnimTime = OverrideAnimTime;
					animPlayer.animTime = AnimTime;
					_player = animPlayer;
				}
			}
			else
			{
				PlayerAnimPlayer playerAnimPlayer = new GameObject("[Architect] Anim Player Block").AddComponent<PlayerAnimPlayer>();
				playerAnimPlayer.Block = this;
				playerAnimPlayer.clipName = ClipName;
				playerAnimPlayer.takeCtrl = TakeCtrl;
				playerAnimPlayer.clearXVel = ClearXVel;
				playerAnimPlayer.clearYVel = ClearYVel;
				playerAnimPlayer.overrideAnimTime = OverrideAnimTime;
				playerAnimPlayer.animTime = AnimTime;
				_player = playerAnimPlayer;
			}
		}

		public override object GetValue(string id)
		{
			return _player.GetClip();
		}

		protected override void Trigger(string id)
		{
			if (id == "Start")
			{
				_player.Play();
			}
			else
			{
				_player.Stop();
			}
		}
	}
	public class BroadcastBlock : LocalBlock
	{
		public GameObject TargetPrefab;

		public string ActualEventName;

		public string EventName = string.Empty;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Broadcast");

		protected override string Name => "Broadcast";

		protected override void Trigger(string id)
		{
			DoBroadcast(EventName);
			if (Object.op_Implicit((Object)(object)TargetPrefab))
			{
				TargetPrefab.BroadcastEvent(ActualEventName);
			}
		}

		public static void DoBroadcast(string eventName)
		{
			foreach (ReceiveBlock.RcEvent item in ReceiveBlock.RcEvent.Events.Where((ReceiveBlock.RcEvent e) => e.Block.EventName.Equals(eventName, StringComparison.InvariantCultureIgnoreCase)))
			{
				item.Block.Event("OnReceive");
			}
		}
	}
	public class CollectionViewBlock : CollectionBlock<ShopBlock.ShopItemBlock>
	{
		public class CollectionItemBlock : ChildBlock
		{
			public string ItemId = "Rosary_Set_Small";

			protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Available", "Boolean"));

			protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnPurchase");

			public override void SetupReference()
			{
			}
		}

		private static GameObject _deskPrefab;

		protected override string Name => "Collection View";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Open");

		protected override string ChildName => "Collection Item";

		protected override bool NeedsGap => true;

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("Belltown_Room_Spare", "furnishings/Desk Group/desk", delegate(GameObject o)
			{
				o.SetActive(false);
				_deskPrefab = Object.Instantiate<GameObject>(o);
				Object.DontDestroyOnLoad((Object)(object)_deskPrefab);
			}));
		}

		public override void SetupReference()
		{
			GameObject val = Object.Instantiate<GameObject>(_deskPrefab);
			((Object)val).name = "[Architect] Collection View";
		}

		protected override void Trigger(string trigger)
		{
		}
	}
	public class CrestBlock : ScriptBlock
	{
		public class CrestBlockRef : MonoBehaviour
		{
			public CrestBlock Block;

			private void OnEnable()
			{
				References.Add(this);
			}

			private void OnDisable()
			{
				References.Remove(this);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass17_0
		{
			public ToolCrest crest;

			internal void <Unlock>b__0()
			{
				crest.Unlock();
				ToolItemManager.AutoEquip(crest, false, false);
				HeroController.instance.RegainControl();
			}
		}

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

			private object <>2__current;

			public ToolCrest crest;

			private <>c__DisplayClass17_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass17_0();
					<>8__1.crest = crest;
					<>2__current = HeroController.instance.FreeControl();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					((UIMsgBase<ToolCrest>)(object)_prefab).Setup(<>8__1.crest);
					UIMsgBase<ToolCrest>.Spawn(<>8__1.crest, (UIMsgBase<ToolCrest>)(object)_prefab, (Action)delegate
					{
						<>8__1.crest.Unlock();
						ToolItemManager.AutoEquip(<>8__1.crest, false, false);
						HeroController.instance.RegainControl();
					});
					return false;
				}
			}

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

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

		private static ToolCrestUIMsg _prefab;

		private static readonly List<CrestBlockRef> References = new List<CrestBlockRef>();

		public string CrestName;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "Set", "Unlock", "SilentUnlock" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnUpdate");

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("Equipped", "Boolean"),
			("Unlocked", "Boolean")
		});

		protected override string Name => "Crest Control";

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("prompts_assets_all", "Assets/Prefabs/UI/Messages/Tool Crest UI Msg.prefab", delegate(GameObject o)
			{
				_prefab = o.GetComponent<ToolCrestUIMsg>();
			}, notSceneBundle: true));
			ToolItemManager.OnEquippedStateChanged += delegate
			{
				References.RemoveAll((CrestBlockRef r) => !Object.op_Implicit((Object)(object)r));
				foreach (CrestBlockRef reference in References)
				{
					reference.Block.Event("OnUpdate");
				}
			};
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			CrestBlockRef crestBlockRef = new GameObject("[Architect] Crest Block Ref").AddComponent<CrestBlockRef>();
			crestBlockRef.Block = this;
			References.Add(crestBlockRef);
		}

		public override void Reset()
		{
			CrestName = "";
		}

		public override object GetValue(string id)
		{
			return PlayerData.instance.CurrentCrestID == CrestName;
		}

		protected override void Trigger(string trigger)
		{
			ToolCrest crestByName = ToolItemManager.GetCrestByName(CrestName);
			if (!Object.op_Implicit((Object)(object)crestByName))
			{
				return;
			}
			if (!(trigger == "Set"))
			{
				if (trigger == "Unlock")
				{
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Unlock(crestByName));
				}
				else
				{
					crestByName.Unlock();
				}
			}
			else
			{
				ToolItemManager.AutoEquip(crestByName, false, false);
			}
		}

		[IteratorStateMachine(typeof(<Unlock>d__17))]
		private static IEnumerator Unlock(ToolCrest crest)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Unlock>d__17(0)
			{
				crest = crest
			};
		}
	}
	public class TitleBlock : ScriptBlock
	{
		public string Header = "";

		public string Body = "";

		public string Footer = "";

		public int TitleType;

		public bool WaitForCancel;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Display", "Cancel" });

		protected override string Name => "Title Display";

		protected override void Trigger(string trigger)
		{
			if (trigger == "Display")
			{
				TitleUtils.DisplayTitle(Header, Body, Footer, TitleType, WaitForCancel);
			}
			else
			{
				TitleUtils.CancelTitle();
			}
		}
	}
	public class TextBlock : ScriptBlock
	{
		private TextDisplay _display;

		public string Text = "";

		public float OffsetY;

		public int VerticalAlignment;

		public int HorizontalAlignment;

		public Color TextColour = Color.white;

		public bool Decorators;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Display", "Stop" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnClose");

		protected override string Name => "Text Display";

		public override void Reset()
		{
			Text = "";
			OffsetY = 0f;
		}

		public override void SetupReference()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			_display = new GameObject("[Architect] Text Display").AddComponent<TextDisplay>();
			_display.Block = this;
			_display.color = TextColour;
			_display.text = Text;
			_display.offsetY = OffsetY;
			_display.verticalAlignment = VerticalAlignment;
			_display.horizontalAlignment = HorizontalAlignment;
			_display.decorators = Decorators;
			_display.Setup();
		}

		protected override void Trigger(string trigger)
		{
			if (trigger == "Stop")
			{
				DialogueBox.EndConversation(true, (Action)null);
			}
			else
			{
				_display.Display();
			}
		}
	}
	public class ChoiceBlock : ScriptBlock
	{
		public string Text;

		public string Item;

		public bool TakeItem;

		public bool UseItem;

		public CurrencyType CurrencyType = (CurrencyType)0;

		public int Cost;

		private ChoiceDisplay _display;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Display");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[2] { "Yes", "No" });

		protected override string Name => "Choice Display";

		public override void SetupReference()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			_display = new GameObject("[Architect] Text Display").AddComponent<ChoiceDisplay>();
			_display.Block = this;
			_display.text = Text;
			_display.item = Item;
			_display.takeItem = TakeItem;
			_display.useItem = UseItem;
			_display.currencyType = CurrencyType;
			_display.cost = Cost;
		}

		protected override void Trigger(string trigger)
		{
			_display.Display();
		}
	}
	public class InputBlock : ScriptBlock
	{
		public class InputDisplay : MonoBehaviour
		{
			[CompilerGenerated]
			private sealed class <DoDisplay>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public InputDisplay <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = HeroController.instance.FreeControl((HeroController _) => InteractManager.CanInteract);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						HeroController.instance.RelinquishControl();
						IsActive = true;
						DialogueYesNoBox.Open((Action)<>4__this.Submit, (Action)<>4__this.Submit, true, <>4__this.Block.Text, (CurrencyType)0, 0, true, true, (SavedItem)null);
						return false;
					}
				}

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

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

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

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						HeroController.instance.RegainControl();
						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 InputBlock Block;

			public void Display()
			{
				((MonoBehaviour)this).StartCoroutine(DoDisplay());
			}

			[IteratorStateMachine(typeof(<DoDisplay>d__2))]
			private IEnumerator DoDisplay()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <DoDisplay>d__2(0)
				{
					<>4__this = this
				};
			}

			private void Submit()
			{
				IsActive = false;
				if (Object.op_Implicit((Object)(object)this))
				{
					((MonoBehaviour)this).StartCoroutine(RegainControlDelayed());
					Block.Event("OnSubmit");
				}
			}

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

		public string Text;

		private InputDisplay _display;

		public static bool IsActive;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Display");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnSubmit");

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Input", "Text"));

		protected override string Name => "Input Display";

		public static void Init()
		{
		}

		public override void SetupReference()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_display = new GameObject("[Architect] Text Display").AddComponent<InputDisplay>();
			_display.Block = this;
		}

		protected override void Trigger(string trigger)
		{
			_display.Display();
		}
	}
	public class SongBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <RemoveText>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SongBlock <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(<>4__this.Delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					NeedolinMsgBox.RemoveText((ILocalisedTextCollection)(object)<>4__this._collection);
					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 string Text = "";

		public float Delay = 1f;

		private LocalisedTextCollection _collection;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Display");

		protected override string Name => "Song Display";

		public override void Reset()
		{
			Text = "";
			Delay = 1f;
		}

		public override void SetupReference()
		{
			//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_002c: Expected O, but got Unknown
			_collection = ScriptableObject.CreateInstance<LocalisedTextCollection>();
			_collection.data = new LocalisedTextCollectionData(new LocalisedString("ArchitectMod", Text));
		}

		protected override void Trigger(string trigger)
		{
			NeedolinMsgBox.AddText((ILocalisedTextCollection)(object)_collection, true, true);
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(RemoveText());
		}

		[IteratorStateMachine(typeof(<RemoveText>d__10))]
		private IEnumerator RemoveText()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RemoveText>d__10(0)
			{
				<>4__this = this
			};
		}
	}
	public class EndingBlock : LocalBlock
	{
		public class CustomSaveArtData : MonoBehaviour
		{
			public Image img;
		}

		public string CustomSprite = string.Empty;

		public bool Point;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "GrantEnding", "PlayCredits" });

		protected override string Name => "Ending Control";

		public static void Init()
		{
			typeof(SaveSlotCompletionIcons).Hook("Awake", (Action<Action<SaveSlotCompletionIcons>, SaveSlotCompletionIcons>)delegate(Action<SaveSlotCompletionIcons> orig, SaveSlotCompletionIcons self)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				orig(self);
				GameObject val = Object.Instantiate<GameObject>(self.completionIcons[0].icon, ((Component)self).transform, true);
				((Object)val).name = "Custom Icon";
				Image component2 = val.GetComponent<Image>();
				component2.sprite = ArchitectPlugin.BlankSprite;
				((Component)self).gameObject.AddComponent<CustomSaveArtData>().img = component2;
			});
			typeof(SaveSlotCompletionIcons).Hook("SetCompletionIconState", (Action<Action<SaveSlotCompletionIcons, SaveStats>, SaveSlotCompletionIcons, SaveStats>)delegate(Action<SaveSlotCompletionIcons, SaveStats> orig, SaveSlotCompletionIcons self, SaveStats stats)
			{
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				orig(self, stats);
				SaveSlotButton componentInParent = ((Component)self).GetComponentInParent<SaveSlotButton>();
				if (Object.op_Implicit((Object)(object)componentInParent))
				{
					CustomSaveArtData component = ((Component)self).GetComponent<CustomSaveArtData>();
					if (GlobalArchitectData.Instance.CustomSaveArt.TryGetValue(componentInParent.SaveSlotIndex, out var value))
					{
						((Component)self).gameObject.SetActive(true);
						Image img = component.img;
						img.sprite = ArchitectPlugin.BlankSprite;
						CustomAssetManager.DoLoadSprite(value.Item1, value.Item2, 100f, 1, 1, delegate(Sprite[] s)
						{
							img.sprite = s[0];
						});
						foreach (CompletionIcon completionIcon in self.completionIcons)
						{
							completionIcon.icon.SetActive(false);
						}
						((Component)component.img).gameObject.SetActive(true);
					}
					else
					{
						((Component)component.img).gameObject.SetActive(false);
					}
				}
			});
		}

		protected override void Trigger(string id)
		{
			if (id == "GrantEnding")
			{
				int profileID = GameManager.instance.profileID;
				GlobalArchitectData.Instance.CustomSaveArt[profileID] = (CustomSprite, Point);
			}
			else
			{
				GameManager.instance.ChangeToScene("End_Credits", "", 0f);
			}
		}
	}
	public class EnemyBlock : ScriptBlock
	{
		public int Health;

		public AttackTypes AttackType;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[4] { "Damage", "Heal", "CappedHeal", "Set" });

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("Target", "Enemy"),
			("Multiplier", "Number")
		});

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Path", "Text"));

		protected override string Name => "Enemy Control";

		public override void Reset()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Health = 1;
			AttackType = (AttackTypes)1;
		}

		public override object GetValue(string id)
		{
			HealthManager variable = GetVariable<HealthManager>("Target");
			return Object.op_Implicit((Object)(object)variable) ? ((Component)variable).transform.GetPath() : "";
		}

		protected override void Trigger(string trigger)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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)
			HealthManager variable = GetVariable<HealthManager>("Target");
			if (Object.op_Implicit((Object)(object)variable))
			{
				switch (trigger)
				{
				case "Damage":
					variable.TakeDamage(new HitInstance
					{
						Source = ((Component)variable).gameObject,
						AttackType = AttackType,
						NailElement = (NailElements)0,
						DamageDealt = (int)((float)Health * GetVariable<float>("Multiplier", 1)),
						ToolDamageFlags = (ToolDamageFlags)0,
						SpecialType = (SpecialTypes)0,
						SlashEffectOverrides = Array.Empty<GameObject>(),
						HitEffectsType = (EffectsTypes)1,
						SilkGeneration = (HitSilkGeneration)2,
						Multiplier = 1f
					});
					break;
				case "Heal":
					variable.hp += (int)((float)Health * GetVariable<float>("Multiplier", 1));
					break;
				case "Set":
					variable.hp = (int)((float)Health * GetVariable<float>("Multiplier", 1));
					break;
				case "CappedHeal":
					variable.AddHP((int)((float)Health * GetVariable<float>("Multiplier", 1)), variable.initHp);
					break;
				}
			}
		}
	}
	public class ItemBlock : ScriptBlock
	{
		public string ItemName;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[4] { "Give", "GiveSilent", "Take", "Clear" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Obtained", "Boolean"));

		protected override string Name => "Item Control";

		public override void Reset()
		{
			ItemName = "";
		}

		public override object GetValue(string id)
		{
			SavedItem savedItem = MiscUtils.GetSavedItem(ItemName);
			if (1 == 0)
			{
			}
			MateriumItem val = (MateriumItem)(object)((savedItem is MateriumItem) ? savedItem : null);
			object result;
			if (val == null)
			{
				CollectableItem val2 = (CollectableItem)(object)((savedItem is CollectableItem) ? savedItem : null);
				if (val2 == null)
				{
					ToolItem val3 = (ToolItem)(object)((savedItem is ToolItem) ? savedItem : null);
					result = ((val3 == null) ? null : ((object)val3.IsUnlocked));
				}
				else
				{
					result = val2.CollectedAmount > 0;
				}
			}
			else
			{
				result = val.IsCollected;
			}
			if (1 == 0)
			{
			}
			return result;
		}

		protected override void Trigger(string trigger)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			SavedItem savedItem = MiscUtils.GetSavedItem(ItemName);
			if (!Object.op_Implicit((Object)(object)savedItem))
			{
				return;
			}
			switch (trigger)
			{
			case "Give":
				savedItem.Get(true);
				break;
			case "GiveSilent":
				savedItem.Get(false);
				break;
			case "Take":
			case "Clear":
			{
				SavedItem val = savedItem;
				SavedItem val2 = val;
				MateriumItem val3 = (MateriumItem)(object)((val2 is MateriumItem) ? val2 : null);
				if (val3 == null)
				{
					CollectableItem val4 = (CollectableItem)(object)((val2 is CollectableItem) ? val2 : null);
					if (val4 == null)
					{
						ToolItem val5 = (ToolItem)(object)((val2 is ToolItem) ? val2 : null);
						if (val5 != null)
						{
							Data savedData = val5.SavedData;
							savedData.IsUnlocked = false;
							val5.SavedData = savedData;
						}
					}
					else
					{
						val4.Take((trigger == "Take") ? 1 : 999, true);
					}
				}
				else
				{
					Data savedData2 = val3.SavedData;
					savedData2.IsCollected = false;
					val3.SavedData = savedData2;
				}
				break;
			}
			}
		}
	}
	public class JournalEntryBlock : ScriptBlock
	{
		public string EntryName;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Increment", "Complete" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("Seen", "Number"),
			("Completed", "Boolean")
		});

		protected override string Name => "Journal Entry Control";

		public override void Reset()
		{
			EntryName = "";
		}

		protected override void Trigger(string trigger)
		{
			EnemyJournalRecord val = ((IEnumerable<EnemyJournalRecord>)((NamedScriptableObjectList<EnemyJournalRecord>)(object)EnemyJournalManager.Instance.recordList).list).FirstOrDefault((Func<EnemyJournalRecord, bool>)((EnemyJournalRecord o) => ((Object)o).name == EntryName));
			if (Object.op_Implicit((Object)(object)val))
			{
				if (trigger == "Increment")
				{
					((SavedItem)val).Get(true);
				}
				else
				{
					((SavedItem)val).Get(val.killsRequired, true);
				}
			}
		}

		public override object GetValue(string id)
		{
			EnemyJournalRecord val = ((IEnumerable<EnemyJournalRecord>)((NamedScriptableObjectList<EnemyJournalRecord>)(object)EnemyJournalManager.Instance.recordList).list).FirstOrDefault((Func<EnemyJournalRecord, bool>)((EnemyJournalRecord o) => ((Object)o).name == EntryName));
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			if (id == "Seen")
			{
				return val.KillCount;
			}
			return val.KillCount == val.killsRequired;
		}
	}
	public class LegacyTravelBlock : ScriptBlock
	{
		public class TravelBtn : MonoBehaviour
		{
			public TravelLoc Block;

			public FastTravelLocations loc;

			public FastTravelMapPiece piece;
		}

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

			private object <>2__current;

			public LegacyTravelBlock <>4__this;

			private SetTextMeshProGameText <setTitle>5__1;

			private bool <hasSet>5__2;

			private MenuButtonIcon[] <>s__3;

			private int <>s__4;

			private MenuButtonIcon <icon>5__5;

			private int <i>5__6;

			private TravelLoc <travelLoc>5__7;

			private UISelectionListItem <obj>5__8;

			private TravelBtn <btn>5__9;

			private SetTextMeshProGameText <set>5__10;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<setTitle>5__1 = null;
				<>s__3 = null;
				<icon>5__5 = null;
				<travelLoc>5__7 = null;
				<obj>5__8 = null;
				<btn>5__9 = null;
				<set>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0275: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0318: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>s__3 = ((Component)_ftm).GetComponentsInChildren<MenuButtonIcon>();
					for (<>s__4 = 0; <>s__4 < <>s__3.Length; <>s__4++)
					{
						<icon>5__5 = <>s__3[<>s__4];
						((ActionButtonIconBase)<icon>5__5).uibs = UIManager.instance.uiButtonSkins;
						<icon>5__5 = null;
					}
					<>s__3 = null;
					<setTitle>5__1 = ((Component)((Component)_ftm).transform.Find("Station List").Find("List").Find("Title Box")
						.Find("Title")).GetComponent<SetTextMeshProGameText>();
					<setTitle>5__1.text = new LocalisedString("ArchitectMod", <>4__this.Title);
					<setTitle>5__1.setTextOn.text = <>4__this.Title;
					_map.sprite = <>4__this.GetVariable<Sprite>("Map");
					_top.sprite = <>4__this.GetVariable<Sprite>("Top");
					((Component)((Component)_ftm).transform.GetChild(0).GetChild(1)).gameObject.SetActive(!Object.op_Implicit((Object)(object)_top.sprite));
					_bot.sprite = <>4__this.GetVariable<Sprite>("Bottom");
					((Component)((Component)_ftm).transform.GetChild(0).GetChild(0)).gameObject.SetActive(!Object.op_Implicit((Object)(object)_bot.sprite));
					<hasSet>5__2 = false;
					<i>5__6 = 0;
					while (<i>5__6 < 12)
					{
						<travelLoc>5__7 = <>4__this.GetVariable<TravelLoc>($"Dest {<i>5__6 + 1}");
						<obj>5__8 = ((FastTravelMapBase<FastTravelLocations>)(object)_ftm).list.listItems[<i>5__6];
						<btn>5__9 = ((Component)<obj>5__8).GetComponent<TravelBtn>();
						<btn>5__9.Block = <travelLoc>5__7;
						if (<travelLoc>5__7 != null && <travelLoc>5__7.Unlocked)
						{
							((Component)<btn>5__9.piece).transform.localPosition = Vector3.zero;
							((FastTravelMapPieceBase<FastTravelMapButton, FastTravelMap, FastTravelLocations>)(object)<btn>5__9.piece).indicatorOffset = new Vector2(<travelLoc>5__7.XPos, <travelLoc>5__7.YPos);
							<set>5__10 = ((Component)<obj>5__8).GetComponent<SetTextMeshProGameText>();
							<set>5__10.text = new LocalisedString("ArchitectMod", <travelLoc>5__7.ListName);
							<set>5__10.setTextOn.text = <travelLoc>5__7.ListName;
							if (!<hasSet>5__2)
							{
								<hasSet>5__2 = true;
								((FastTravelMapBase<FastTravelLocations>)(object)_ftm).AutoSelectLocation = <btn>5__9.loc;
							}
							<travelLoc>5__7 = null;
							<obj>5__8 = null;
							<btn>5__9 = null;
							<set>5__10 = null;
						}
						<i>5__6++;
					}
					if (!<hasSet>5__2)
					{
						return false;
					}
					<>2__current = HeroController.instance.FreeControl((HeroController _) => !GameManager.instance.isPaused);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					PlayerData.instance.disablePause = true;
					((FastTravelMapBase<FastTravelLocations>)(object)_ftm).Open();
					((Component)((Component)_ftm).transform.GetChild(1).GetChild(0)).gameObject.SetActive(false);
					((Component)((Component)_ftm).transform.GetChild(1).GetChild(2)).gameObject.SetActive(false);
					((FastTravelMapBase<FastTravelLocations>)(object)_ftm).LocationConfirmed += <>4__this.<Coroutine>g__Dismiss|16_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();
			}
		}

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RegainControl();
					PlayerData.instance.disablePause = false;
					return false;
				}
			}

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

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

		private static FastTravelMap _ftm;

		private static SpriteRenderer _map;

		private static SpriteRenderer _top;

		private static SpriteRenderer _bot;

		public string Title = "Sample Text";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Display");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Dismiss");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[17]
		{
			ScriptBlock.Space,
			ScriptBlock.Space,
			("Map", "Sprite"),
			("Top", "Sprite"),
			("Bottom", "Sprite"),
			("Dest 1", "Travel"),
			("Dest 2", "Travel"),
			("Dest 3", "Travel"),
			("Dest 4", "Travel"),
			("Dest 5", "Travel"),
			("Dest 6", "Travel"),
			("Dest 7", "Travel"),
			("Dest 8", "Travel"),
			("Dest 9", "Travel"),
			("Dest 10", "Travel"),
			("Dest 11", "Travel"),
			("Dest 12", "Travel")
		});

		protected override string Name => "Travel List (Legacy)";

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_areabellway", "Assets/Prefabs/UI/Fast Travel Map.prefab", delegate(GameObject o)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0242: Unknown result type (might be due to invalid IL or missing references)
				o = Object.Instantiate<GameObject>(o);
				Object.DontDestroyOnLoad((Object)(object)o);
				o.transform.position = Vector3.zero;
				Object.Destroy((Object)(object)((Component)o.transform.GetChild(3).GetChild(0)).gameObject);
				_ftm = o.GetComponent<FastTravelMap>();
				ConstrainPosition val = ((Component)o.transform.GetChild(1)).gameObject.AddComponent<ConstrainPosition>();
				val.constrainX = true;
				val.constrainY = true;
				_map = Object.Instantiate<GameObject>(((Component)o.transform.Find("backing")).gameObject).GetComponent<SpriteRenderer>();
				((Component)_map).transform.parent = o.transform;
				((Object)_map).name = "Map";
				((Component)_map).transform.localScale = Vector3.one;
				((Component)_map).transform.position = new Vector3(-6f, 0f, 2f);
				_top = Object.Instantiate<GameObject>(((Component)o.transform.Find("backing")).gameObject).GetComponent<SpriteRenderer>();
				((Component)_top).transform.parent = o.transform;
				((Object)_top).name = "Top";
				((Component)_top).transform.localScale = Vector3.one;
				((Component)_top).transform.position = new Vector3(0f, 6.9173f, 2f);
				_bot = Object.Instantiate<GameObject>(((Component)o.transform.Find("backing")).gameObject).GetComponent<SpriteRenderer>();
				((Component)_bot).transform.parent = o.transform;
				((Object)_bot).name = "Bottom";
				((Component)_bot).transform.localScale = Vector3.one;
				((Component)_bot).transform.position = new Vector3(0f, -6.7024f, 2f);
				FastTravelMapButton[] componentsInChildren = o.GetComponentsInChildren<FastTravelMapButton>();
				foreach (FastTravelMapButton btn in componentsInChildren)
				{
					((FastTravelMapButtonBase<FastTravelLocations>)(object)btn).playerDataBool = "";
					TravelBtn travelBtn = ((Component)btn).gameObject.AddComponent<TravelBtn>();
					travelBtn.loc = ((FastTravelMapButtonBase<FastTravelLocations>)(object)btn).targetLocation;
					FastTravelMapPiece piece2 = o.GetComponentsInChildren<FastTravelMapPiece>().First((FastTravelMapPiece piece) => (Object)(object)((FastTravelMapPieceBase<FastTravelMapButton, FastTravelMap, FastTravelLocations>)(object)piece).pairedButton == (Object)(object)btn);
					travelBtn.piece = piece2;
				}
			}, notSceneBundle: true));
			typeof(FastTravelMapButtonBase<FastTravelLocations>).Hook("IsUnlocked", (Func<Func<FastTravelMapButtonBase<FastTravelLocations>, bool>, FastTravelMapButtonBase<FastTravelLocations>, bool>)delegate(Func<FastTravelMapButtonBase<FastTravelLocations>, bool> orig, FastTravelMapButtonBase<FastTravelLocations> self)
			{
				TravelBtn component2 = ((Component)self).GetComponent<TravelBtn>();
				return Object.op_Implicit((Object)(object)component2) ? (component2.Block?.Unlocked ?? false) : orig(self);
			});
			typeof(FastTravelMapButtonBase<FastTravelLocations>).Hook("Submit", (Action<Action<FastTravelMapButtonBase<FastTravelLocations>>, FastTravelMapButtonBase<FastTravelLocations>>)delegate(Action<FastTravelMapButtonBase<FastTravelLocations>> orig, FastTravelMapButtonBase<FastTravelLocations> self)
			{
				TravelBtn component = ((Component)self).GetComponent<TravelBtn>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.Block.Event("OnChoose");
				}
				orig(self);
			});
		}

		public override void Reset()
		{
			Title = "Sample Text";
		}

		protected override void Trigger(string trigger)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Coroutine());
		}

		[IteratorStateMachine(typeof(<Coroutine>d__16))]
		private IEnumerator Coroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Coroutine>d__16(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<RegainControlDelayed>d__17))]
		private static IEnumerator RegainControlDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RegainControlDelayed>d__17(0);
		}
	}
	public class TravelLoc : ScriptBlock
	{
		public string ListName = "Sample Text";

		public float XPos;

		public float YPos;

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Unlocked", "Boolean"));

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("This", "Travel"));

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnChoose");

		protected override string Name => "Travel Point (Legacy)";

		public bool Unlocked => GetVariable<bool>("Unlocked", true);

		public override void Reset()
		{
			ListName = "Sample Text";
			XPos = -99999f;
			YPos = -99999f;
		}

		public override object GetValue(string id)
		{
			return this;
		}
	}
	public class MultiplayerInBlock : ScriptBlock
	{
		public string EventName;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Broadcast");

		protected override string Name => "Multiplayer Event";

		protected override void Trigger(string id)
		{
			CoopManager.Instance.ShareEvent(GameManager.instance.sceneName, EventName);
		}
	}
	public class HpBlock : PlayerBlock
	{
		public static int LastHit;

		public int Amount;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[6] { "Max", "Give", "GiveBlue", "Take", "TakeInstant", "TakeHazard" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[5] { "OnHazardRespawn", "OnDamage", "OnDeath", "OnHeal", "OnHealFail" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[7]
		{
			("LastHit", "Number"),
			ScriptBlock.Space,
			("Amount", "Number"),
			ScriptBlock.Space,
			("MaxAmount", "Number"),
			ScriptBlock.Space,
			("Lifeblood", "Number")
		});

		protected override string Name => "Health Control";

		public override void Reset()
		{
			Amount = 0;
		}

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "Max":
				HeroController.instance.AddHealth(99999);
				break;
			case "Give":
				HeroController.instance.AddHealth(Amount);
				break;
			case "GiveBlue":
			{
				for (int i = 0; i < Amount; i++)
				{
					GameManager.instance.AddBlueHealthQueued();
				}
				break;
			}
			case "Take":
				HeroController.instance.TakeDamage(((Component)HeroController.instance).gameObject, (CollisionSide)4, Amount, (HazardType)1, (DamagePropertyFlags)0);
				break;
			case "TakeInstant":
				HeroController.instance.DoSpecialDamage(Amount, false, "Instant", true, true, true, false);
				break;
			case "TakeHazard":
				HeroController.instance.TakeHealth(Amount - 1);
				HeroController.instance.TakeDamage(((Component)HeroController.instance).gameObject, (CollisionSide)4, 1, (HazardType)2, (DamagePropertyFlags)0);
				break;
			}
		}

		public override object GetValue(string id)
		{
			if (1 == 0)
			{
			}
			int num = id switch
			{
				"Amount" => PlayerData.instance.health, 
				"LastHit" => LastHit, 
				"MaxAmount" => PlayerData.instance.maxHealth, 
				"Lifeblood" => PlayerData.instance.healthBlue, 
				_ => 0, 
			};
			if (1 == 0)
			{
			}
			return num;
		}
	}
	public class InvulBlock : ScriptBlock
	{
		public static bool Invulnerable;

		public float Duration;

		protected override string Name => "Invulnerable Control";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "MakeInvulnerable", "MakeVulnerable", "SetInvulTime" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Duration", "Number"));

		public static void Init()
		{
			HookUtils.OnHeroAwake = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroAwake, (Action<HeroController>)delegate
			{
				Invulnerable = false;
			});
		}

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "MakeInvulnerable":
				Invulnerable = true;
				PlayerData.instance.isInvincible = true;
				break;
			case "MakeVulnerable":
				Invulnerable = false;
				PlayerData.instance.isInvincible = false;
				break;
			case "SetInvulTime":
				HeroController.instance.StartInvulnerable(Duration);
				break;
			}
		}

		public override object GetValue(string id)
		{
			return HeroController.instance.invulnerableDuration;
		}
	}
	public class SilkBlock : ScriptBlock
	{
		public class SilkControl : MonoBehaviour
		{
			public SilkBlock Block;

			private void Start()
			{
				_onSilkGain = (Action)Delegate.Combine(_onSilkGain, new Action(OnGain));
			}

			private void OnDisable()
			{
				_onSilkGain = (Action)Delegate.Remove(_onSilkGain, new Action(OnGain));
			}

			public void OnGain()
			{
				Block.Event("OnGain");
			}
		}

		private static Action _onSilkGain;

		public int Amount;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[4] { "Max", "Give", "Take", "BreakCocoon" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnGain");

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Amount", "Number"));

		protected override string Name => "Silk Control";

		public static void Init()
		{
			typeof(PlayerData).Hook("AddSilk", (Func<Func<PlayerData, int, bool>, PlayerData, int, bool>)delegate(Func<PlayerData, int, bool> orig, PlayerData self, int amount)
			{
				_onSilkGain?.Invoke();
				return orig(self, amount);
			});
		}

		public override void Reset()
		{
			Amount = 0;
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("[Architect] Silk Control Ref");
			val.AddComponent<SilkControl>().Block = this;
		}

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "Max":
				HeroController.instance.AddSilk(9999, true);
				break;
			case "Give":
				HeroController.instance.AddSilk(Amount, true);
				break;
			case "Take":
				HeroController.instance.TakeSilk(Amount);
				break;
			case "BreakCocoon":
				if (!Utility.IsNullOrWhiteSpace(PlayerData.instance.HeroCorpseScene))
				{
					HeroController.instance.CocoonBroken();
					EventRegister.SendEvent(EventRegisterEvents.BreakHeroCorpse, (GameObject)null);
				}
				break;
			}
		}

		public override object GetValue(string id)
		{
			return PlayerData.instance.silk;
		}
	}
	public class CurrencyBlock : ScriptBlock
	{
		public int Amount;

		public CurrencyType CurrencyType = (CurrencyType)0;

		public bool ShowCounter = true;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Give", "Take" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Amount", "Number"));

		protected override string Name => "Currency Control";

		public override void Reset()
		{
			Amount = 0;
		}

		protected override void Trigger(string trigger)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (trigger == "Give")
			{
				HeroController.instance.AddCurrency(Amount, CurrencyType, ShowCounter);
				return;
			}
			int num = Math.Min(HeroController.instance.GetCurrencyAmount(CurrencyType), Amount);
			HeroController.instance.TakeCurrency(num, CurrencyType, ShowCounter);
		}

		public override object GetValue(string id)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return HeroController.instance.GetCurrencyAmount(CurrencyType);
		}
	}
	public class StatusBlock : ScriptBlock
	{
		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[5] { "Maggot", "Unmaggot", "Void", "Plasmify", "Deplasmify" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[3]
		{
			("Maggoted", "Boolean"),
			("Frosted", "Boolean"),
			("Plasmified", "Boolean")
		});

		protected override string Name => "Status Control";

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "Void":
				HeroController.instance.ActivateVoidAcid();
				break;
			case "Maggot":
				HeroController.instance.SetIsMaggoted(true);
				break;
			case "Unmaggot":
				HeroController.instance.SetIsMaggoted(false);
				break;
			case "Plasmify":
				HeroController.instance.HitMaxBlueHealth();
				HeroController.instance.HitMaxBlueHealthBurst();
				break;
			case "Deplasmify":
				HeroController.instance.ResetLifebloodState();
				break;
			}
		}

		public override object GetValue(string id)
		{
			if (1 == 0)
			{
			}
			bool flag = id switch
			{
				"Maggoted" => HeroController.instance.cState.isMaggoted, 
				"Plasmified" => HeroController.instance.IsInLifebloodState, 
				"Frosted" => HeroController.instance.cState.isFrosted, 
				_ => false, 
			};
			if (1 == 0)
			{
			}
			return flag;
		}
	}
	public class PngBlock : ScriptBlock
	{
		private SpriteRenderer _renderer;

		public string Url;

		public bool Point;

		public float Ppu;

		protected override string Name => "Custom PNG";

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Current Sprite", "Sprite"));

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			GameObject val = new GameObject("[Architect] Custom PNG");
			val.transform.localPosition = new Vector3(-9999f, -9999f);
			GameObject val2 = val;
			val2.SetActive(false);
			_renderer = val2.AddComponent<SpriteRenderer>();
			PngObject pngObject = val2.AddComponent<PngObject>();
			pngObject.url = Url;
			pngObject.point = Point;
			pngObject.ppu = Ppu;
			val2.SetActive(true);
		}

		public override object GetValue(string id)
		{
			return _renderer.sprite;
		}
	}
	public class PowerupGetBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass18_0
		{
			public PowerUpGetMsg msg;

			public PowerupGetBlock <>4__this;
		}

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

			private object <>2__current;

			public PowerupGetBlock <>4__this;

			private <>c__DisplayClass18_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass18_0();
					<>8__1.<>4__this = <>4__this;
					<>2__current = HeroController.instance.FreeControl();
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<>8__1.msg = null;
					ref PowerUpGetMsg msg = ref <>8__1.msg;
					UIMsgBase<PowerUps> obj = UIMsgBase<PowerUps>.Spawn((PowerUps)0, (UIMsgBase<PowerUps>)(object)_pugm, (Action)End);
					msg = (PowerUpGetMsg)(object)((obj is PowerUpGetMsg) ? obj : null);
					if (!Object.op_Implicit((Object)(object)<>8__1.msg))
					{
						return false;
					}
					<>8__1.msg.lineSprite.sprite = <>4__this.GetVariable<Sprite>("Outline");
					<>8__1.msg.solidSprite.sprite = <>4__this.GetVariable<Sprite>("Solid");
					<>8__1.msg.glowSprite.sprite = <>4__this.GetVariable<Sprite>("Glow");
					<>8__1.msg.promptSprite.sprite = <>4__this.GetVariable<Sprite>("Prompt");
					<>8__1.msg.nameText.text = <>4__this.NameText;
					<>8__1.msg.prefixText.text = <>4__this.PrefixText;
					<>8__1.msg.promptButtonSingleText.text = <>4__this.SuffixText;
					<>8__1.msg.promptButtonModifierText.text = "";
					<>8__1.msg.descTextTop.text = <>4__this.DescTopText;
					<>8__1.msg.descTextBot.text = <>4__this.DescBotText;
					if (Utility.IsNullOrWhiteSpace(<>4__this.ButtonText))
					{
						((Component)<>8__1.msg.promptButtonSingle).gameObject.SetActive(false);
						Extensions.SetLocalPositionX(<>8__1.msg.promptButtonSingleText.transform, 0f);
						<>8__1.msg.promptButtonSingleText.alignment = (TextAlignmentOptions)5;
					}
					else
					{
						((TMP_Text)((ActionButtonIconBase)<>8__1.msg.promptButtonSingle).textContainer.textMeshPro).text = MiscFixers.SubstituteVars(<>4__this.ButtonText);
					}
					((Component)<>8__1.msg.promptButtonModifier).gameObject.SetActive(false);
					Extensions.SetLocalPosition2D(((Component)<>8__1.msg).transform, Vector2.zero);
					GameCameras.instance.HUDOut();
					HeroController.instance.AddInputBlocker((object)<>8__1.msg);
					return false;
				}
				}
				void End()
				{
					HeroController.instance.RemoveInputBlocker((object)((<>c__DisplayClass18_0)this).msg);
					GameCameras.instance.HUDIn();
					((<>c__DisplayClass18_0)this).<>4__this.Event("Dismiss");
				}
			}

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

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

		private static PowerUpGetMsg _pugm;

		public string PrefixText = "";

		public string NameText = "";

		public string SuffixText = "";

		public string ButtonText = "";

		public string DescTopText = "";

		public string DescBotText = "";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Display");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Dismiss");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[6]
		{
			ScriptBlock.Space,
			ScriptBlock.Space,
			("Outline", "Sprite"),
			("Solid", "Sprite"),
			("Glow", "Sprite"),
			("Prompt", "Sprite")
		});

		protected override string Name => "Powerup Display";

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("prompts_assets_all.bundle", "Assets/Prefabs/UI/Hornet UI/Ancestral_Art_Get_Prompt.prefab", delegate(GameObject o)
			{
				o.SetActive(true);
				_pugm = o.GetComponent<PowerUpGetMsg>();
			}, notSceneBundle: true));
		}

		public override void Reset()
		{
			PrefixText = "";
			NameText = "";
			SuffixText = "";
			ButtonText = "";
			DescTopText = "";
			DescBotText = "";
		}

		protected override void Trigger(string trigger)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Coroutine());
		}

		[IteratorStateMachine(typeof(<Coroutine>d__18))]
		private IEnumerator Coroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Coroutine>d__18(0)
			{
				<>4__this = this
			};
		}
	}
	public class QuestBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass11_0
		{
			public QuestBlock <>4__this;

			public FullQuestBase quest;

			internal void <TriggerRoutine>b__1()
			{
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>4__this.RegainControl());
				PrepareCourierItems(quest);
				<>4__this.Event("OnAccept");
			}

			internal void <TriggerRoutine>b__2()
			{
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>4__this.RegainControl());
				<>4__this.Event("OnDecline");
			}

			internal void <TriggerRoutine>b__3()
			{
				<>4__this.Event("OnAcceptDismiss");
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>4__this.RegainControl());
				GameCameras.instance.HUDIn();
			}

			internal void <TriggerRoutine>b__4()
			{
				<>4__this.Event("OnCompleteDismiss");
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>4__this.RegainControl());
				GameCameras.instance.HUDIn();
			}
		}

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

			private object <>2__current;

			public QuestBlock <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RegainControl();
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public string trigger;

			public QuestBlock <>4__this;

			private <>c__DisplayClass11_0 <>8__1;

			private Completion <completion>5__2;

			private QuestTarget[] <targets>5__3;

			private bool <set>5__4;

			private string <>s__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<targets>5__3 = null;
				<>s__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0350: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_042a: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass11_0();
					<>8__1.<>4__this = <>4__this;
					ref FullQuestBase quest = ref <>8__1.quest;
					BasicQuestBase byName = ((NamedScriptableObjectList<BasicQuestBase>)(object)QuestManager.instance.masterList).GetByName(<>4__this.QuestName);
					quest = (FullQuestBase)(object)((byName is FullQuestBase) ? byName : null);
					if (!Object.op_Implicit((Object)(object)<>8__1.quest))
					{
						return false;
					}
					<completion>5__2 = <>8__1.quest.Completion;
					string text = trigger;
					<>s__5 = text;
					switch (<>s__5)
					{
					case "Offer":
						<>2__current = HeroController.instance.FreeControl();
						<>1__state = 1;
						return true;
					case "Update":
						QuestManager.ShowQuestUpdatedStandalone((BasicQuestBase)(object)<>8__1.quest);
						break;
					case "Clear":
						<>8__1.quest.Completion = default(Completion);
						break;
					case "Accept":
						<>2__current = HeroController.instance.FreeControl();
						<>1__state = 2;
						return true;
					case "Complete":
						<>2__current = HeroController.instance.FreeControl();
						<>1__state = 3;
						return true;
					case "SilentAccept":
						<completion>5__2.IsAccepted = true;
						<>8__1.quest.Completion = <completion>5__2;
						PrepareCourierItems(<>8__1.quest);
						break;
					case "SilentComplete":
						<>8__1.quest.SilentlyComplete();
						break;
					}
					break;
				}
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					<targets>5__3 = <>8__1.quest.targets;
					<set>5__4 = <targets>5__3.Any((QuestTarget target) => target.Counter is CustomItem.CustomCourierItem customCourierItem && customCourierItem.reward == 0);
					if (<set>5__4)
					{
						<>8__1.quest.targets = Array.Empty<QuestTarget>();
					}
					QuestYesNoBox.Open((Action)delegate
					{
						((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>8__1.<>4__this.RegainControl());
						PrepareCourierItems(<>8__1.quest);
						<>8__1.<>4__this.Event("OnAccept");
					}, (Action)delegate
					{
						((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>8__1.<>4__this.RegainControl());
						<>8__1.<>4__this.Event("OnDecline");
					}, true, <>8__1.quest, true);
					if (<set>5__4)
					{
						<>8__1.quest.targets = <targets>5__3;
					}
					break;
				case 2:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					GameCameras.instance.HUDOut();
					<completion>5__2.IsAccepted = true;
					<completion>5__2.IsCompleted = false;
					<>8__1.quest.Completion = <completion>5__2;
					PrepareCourierItems(<>8__1.quest);
					<>8__1.quest.BeginQuest((Action)delegate
					{
						<>8__1.<>4__this.Event("OnAcceptDismiss");
						((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>8__1.<>4__this.RegainControl());
						GameCameras.instance.HUDIn();
					}, true);
					break;
				case 3:
					<>1__state = -1;
					GameCameras.instance.HUDOut();
					<completion>5__2.IsCompleted = true;
					<>8__1.quest.Completion = <completion>5__2;
					HeroController.instance.RelinquishControl();
					<>8__1.quest.ShowQuestCompleted((Action)delegate
					{
						<>8__1.<>4__this.Event("OnCompleteDismiss");
						((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(<>8__1.<>4__this.RegainControl());
						GameCameras.instance.HUDIn();
					});
					break;
				}
				<targets>5__3 = null;
				<>s__5 = null;
				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 string QuestName;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[7] { "Clear", "Offer", "Update", "Accept", "Complete", "SilentAccept", "SilentComplete" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[4] { "OnAccept", "OnDecline", "OnAcceptDismiss", "OnCompleteDismiss" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[5]
		{
			("Accepted", "Boolean"),
			ScriptBlock.Space,
			("Completed", "Boolean"),
			ScriptBlock.Space,
			("CanComplete", "Boolean")
		});

		protected override string Name => "Custom Quest Control";

		public override void Reset()
		{
			QuestName = "";
		}

		protected override void Trigger(string trigger)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(TriggerRoutine(trigger));
		}

		[IteratorStateMachine(typeof(<TriggerRoutine>d__11))]
		private IEnumerator TriggerRoutine(string trigger)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TriggerRoutine>d__11(0)
			{
				<>4__this = this,
				trigger = trigger
			};
		}

		public static void PrepareCourierItems(FullQuestBase quest)
		{
			//IL_000f: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			QuestTarget[] targets = quest.targets;
			foreach (QuestTarget val in targets)
			{
				if (val.Counter is CustomItem.CustomCourierItem customCourierItem)
				{
					((CollectableItem)customCourierItem).Take(999, false);
					((SavedItem)customCourierItem).Get(val.Count, true);
					quest.rewardCount = customCourierItem.reward;
				}
			}
		}

		[IteratorStateMachine(typeof(<RegainControl>d__13))]
		private IEnumerator RegainControl()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RegainControl>d__13(0)
			{
				<>4__this = this
			};
		}

		public override object GetValue(string id)
		{
			BasicQuestBase byName = ((NamedScriptableObjectList<BasicQuestBase>)(object)QuestManager.instance.masterList).GetByName(QuestName);
			FullQuestBase val = (FullQuestBase)(object)((byName is FullQuestBase) ? byName : null);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return false;
			}
			if (1 == 0)
			{
			}
			bool flag = ((id == "Accepted") ? ((BasicQuestBase)val).IsAccepted : ((!(id == "Completed")) ? val.CanComplete : val.IsCompleted));
			if (1 == 0)
			{
			}
			return flag;
		}
	}
	public class QuestboardBlock : CollectionBlock<QuestboardBlock.QuestBlock>
	{
		public class QuestBlock : ChildBlock
		{
			public string QuestName = string.Empty;

			public BasicQuestBase Quest;

			protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Available", "Boolean"));

			protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnAccept");

			public override void SetupReference()
			{
				ref BasicQuestBase quest = ref Quest;
				BasicQuestBase byName = ((NamedScriptableObjectList<BasicQuestBase>)(object)QuestManager.instance.masterList).GetByName(QuestName);
				quest = ((byName is FullQuestBase) ? byName : null);
			}
		}

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

			private object <>2__current;

			public QuestboardBlock <>4__this;

			private IEnumerator<QuestBlock> <>s__1;

			private QuestBlock <child>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = HeroController.instance.FreeControl((HeroController _) => !GameManager.instance.isPaused);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					if (!Object.op_Implicit((Object)(object)<>4__this._qbi))
					{
						return false;
					}
					((NamedScriptableObjectList<QuestGroupBase>)(object)<>4__this._qbi.questList).Clear();
					<>s__1 = <>4__this.Children.Children.GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<child>5__2 = <>s__1.Current;
							if (<child>5__2.GetVariable<bool>("Available", true) && Object.op_Implicit((Object)(object)<child>5__2.Quest))
							{
								((NamedScriptableObjectList<QuestGroupBase>)(object)<>4__this._qbi.questList).Add((QuestGroupBase)(object)<child>5__2.Quest);
								<child>5__2 = null;
							}
						}
					}
					finally
					{
						if (<>s__1 != null)
						{
							<>s__1.Dispose();
						}
					}
					<>s__1 = null;
					<>4__this._qbi.OpenBoard();
					return false;
				}
			}

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

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

		private static GameObject _questBoard;

		private QuestBoardInteractable _qbi;

		protected override string Name => "Quest Board";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Open");

		protected override string ChildName => "Quest Item";

		protected override bool NeedsGap => true;

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("Belltown", "Town States/Spinner Defeated/Quest Board Pivot/Quest_Board", delegate(GameObject o)
			{
				o = Object.Instantiate<GameObject>(o);
				o.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)o);
				for (int i = 0; i < o.transform.childCount; i++)
				{
					((Component)o.transform.GetChild(i)).gameObject.SetActive(false);
				}
				_questBoard = o;
			}));
		}

		public override void SetupReference()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_questBoard);
			val.transform.position = new Vector3(-9999f, -9999f);
			val.SetActive(true);
			_qbi = val.GetComponent<QuestBoardInteractable>();
			_qbi.questList = ScriptableObject.CreateInstance<QuestBoardList>();
			_qbi.questBoard = Object.Instantiate<QuestItemBoard>(_qbi.questBoardPrefab);
			QuestItemBoard questBoard = _qbi.questBoard;
			questBoard.BoardClosed += delegate(List<BasicQuestBase> e)
			{
				foreach (QuestBlock item in from q in e
					select Children.Children.FirstOrDefault((QuestBlock c) => (Object)(object)c.Quest == (Object)(object)q) into child
					where child != null
					select child)
				{
					item.Event("OnAccept");
					BasicQuestBase quest = item.Quest;
					FullQuestBase val2 = (FullQuestBase)(object)((quest is FullQuestBase) ? quest : null);
					if (Object.op_Implicit((Object)(object)val2))
					{
						Architect.Events.Blocks.Outputs.QuestBlock.PrepareCourierItems(val2);
					}
				}
				HeroController.instance.RegainControl();
			};
			questBoard.GetAvailableQuestsFunc = _qbi.GetDisplayedQuests;
			_qbi.questBoardPrefab = null;
		}

		protected override void Trigger(string trigger)
		{
			((Object)_qbi).name = Guid.NewGuid().ToString();
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Coroutine());
		}

		[IteratorStateMachine(typeof(<Coroutine>d__13))]
		private IEnumerator Coroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Coroutine>d__13(0)
			{
				<>4__this = this
			};
		}
	}
	public class SetLightingBlock : ScriptBlock
	{
		public static bool IsLocked;

		public static float SaturationLock;

		public float R = 1f;

		public float G = 1f;

		public float B = 1f;

		public float Intensity = 1f;

		public float Saturation = 1f;

		public bool Lock;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Set");

		protected override string Name => "Set Lighting";

		public static void Init()
		{
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				IsLocked = false;
				orig(self);
			});
			typeof(CustomSceneManager).Hook("SetLighting", (Action<Action<Color, float>, Color, float>)delegate(Action<Color, float> orig, Color color, float intensity)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				if (!IsLocked)
				{
					orig(color, intensity);
				}
			});
			typeof(ColorCorrectionCurves).Hook("UpdateMaterial", (Action<Action<ColorCorrectionCurves, Material>, ColorCorrectionCurves, Material>)delegate(Action<ColorCorrectionCurves, Material> orig, ColorCorrectionCurves self, Material material)
			{
				if (IsLocked)
				{
					self.saturation = SaturationLock;
				}
				orig(self, material);
			}, typeof(Material));
			HookUtils.OnHeroUpdate = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroUpdate, (Action<HeroController>)delegate
			{
				if (IsLocked)
				{
					GameCameras.instance.colorCorrectionCurves.saturation = SaturationLock;
				}
			});
		}

		public override void Reset()
		{
			R = 1f;
			G = 1f;
			B = 1f;
			Intensity = 1f;
			Saturation = 1f;
			Lock = true;
		}

		protected override void Trigger(string trigger)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			IsLocked = false;
			CustomSceneManager sm = GameManager.instance.sm;
			sm.saturation = Saturation;
			GameCameras.instance.colorCorrectionCurves.saturation = Saturation;
			sm.setSaturation = true;
			SaturationLock = Saturation;
			CustomSceneManager.SetLighting(new Color(R, G, B), Intensity);
			IsLocked = Lock;
		}
	}
	public class ShakeCameraBlock : ScriptBlock
	{
		public int ShakeType;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Shake");

		protected override string Name => "Camera Shake";

		protected override void Trigger(string id)
		{
			CameraManagerReference mainCameraShakeManager = Camera.MainCameraShakeManager;
			int shakeType = ShakeType;
			if (1 == 0)
			{
			}
			CameraShakeProfile val = (CameraShakeProfile)(shakeType switch
			{
				0 => Camera.TinyShake, 
				1 => Camera.SmallShake, 
				2 => Camera.AverageShake, 
				_ => Camera.BigShake, 
			});
			if (1 == 0)
			{
			}
			mainCameraShakeManager.DoShake((ICameraShake)(object)val, (Object)(object)HeroController.instance, false, true, true);
		}
	}
	public class ShopBlock : CollectionBlock<ShopBlock.ShopItemBlock>
	{
		public class ShopItemBlock : ChildBlock
		{
			public string ItemId = "Rosary_Set_Small";

			public string ItemName = string.Empty;

			public string ItemDesc = string.Empty;

			public CurrencyType Currency = (CurrencyType)0;

			public int Cost = 80;

			public string ReqItem = string.Empty;

			public int ReqItemAmount = 1;

			public ShopBlock Shop;

			public ShopItem Item;

			protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Available", "Boolean"));

			protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnPurchase");

			public override void Reset()
			{
				ItemId = "Rosary_Set_Small";
				ItemName = string.Empty;
				ItemDesc = string.Empty;
				Cost = 80;
			}

			public override void SetupReference()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//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_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Expected O, but got Unknown
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Expected O, but got Unknown
				Item = ScriptableObject.CreateInstance<ShopItem>();
				SavedItem savedItem = MiscUtils.GetSavedItem(ItemId);
				Item.savedItem = savedItem;
				Item.questsAppearConditions = Array.Empty<QuestTest>();
				Item.extraAppearConditions = new PlayerDataTest();
				Item.spawnOnPurchaseConditionals = Array.Empty<ConditionalSpawn>();
				Item.setExtraPlayerDataBools = Array.Empty<string>();
				Item.setExtraPlayerDataInts = Array.Empty<PlayerDataIntOperation>();
				Item.displayName = new LocalisedString("ArchitectMod", ItemName);
				Item.description = new LocalisedString("ArchitectMod", ItemDesc);
				Item.currencyType = Currency;
				Item.requiredItemAmount = ReqItemAmount;
				ref CollectableItem requiredItem = ref Item.requiredItem;
				SavedItem savedItem2 = MiscUtils.GetSavedItem(ReqItem);
				requiredItem = (CollectableItem)(object)((savedItem2 is CollectableItem) ? savedItem2 : null);
				Item.cost = Cost;
				Item.onPurchase = new UnityEvent();
				Item.onPurchase.AddListener((UnityAction)delegate
				{
					Event("OnPurchase");
					Shop?.Refresh();
				});
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass14_0
		{
			public PlayMakerFSM sc;

			internal bool <Coroutine>b__1()
			{
				return sc.ActiveStateName == "Idle";
			}
		}

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

			private object <>2__current;

			public ShopBlock <>4__this;

			private <>c__DisplayClass14_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass14_0();
					<>2__current = HeroController.instance.FreeControl((HeroController _) => !GameManager.instance.isPaused);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					<>4__this.Refresh();
					((Component)<>4__this._shopOwner).gameObject.SetActive(true);
					<>8__1.sc = FSMUtility.LocateMyFSM(((ShopOwnerBase)<>4__this._shopOwner).ShopObject, "shop_control");
					<>8__1.sc.SendEvent("SHOP UP");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.sc.ActiveStateName == "Idle"));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					HeroController.instance.RegainControl();
					return false;
				}
			}

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

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

		private static ShopMenuStock _shopPrefab;

		private ShopOwner _shopOwner;

		protected override string Name => "Shop";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Open");

		protected override string ChildName => "Shop Item";

		protected override bool NeedsGap => true;

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("shopui_assets_all.bundle", "Assets/Prefabs/UI/Shop/Shop Menu.prefab", delegate(GameObject o)
			{
				_shopPrefab = o.GetComponent<ShopMenuStock>();
			}, notSceneBundle: true));
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("[Architect] Shop Object");
			val.SetActive(false);
			_shopOwner = val.AddComponent<ShopOwner>();
			((ShopOwnerBase)_shopOwner).shopPrefab = _shopPrefab;
		}

		protected override void Trigger(string trigger)
		{
			foreach (ShopItemBlock child in Children.Children)
			{
				child.Shop = this;
			}
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Coroutine());
		}

		public void Refresh()
		{
			_shopOwner.stock = (from i in Children.Children
				where i.GetVariable<bool>("Available", true) && Object.op_Implicit((Object)(object)i.Item)
				select i.Item).ToArray();
			((ShopOwnerBase)_shopOwner).SpawnUpdateShop();
		}

		[IteratorStateMachine(typeof(<Coroutine>d__14))]
		private IEnumerator Coroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Coroutine>d__14(0)
			{
				<>4__this = this
			};
		}
	}
	public class TimeSlowerBlock : ScriptBlock
	{
		public float ChangeTime;

		public float WaitTime;

		public float ReturnTime;

		public float TargetSpeed;

		public bool NoPause;

		private static int _timeSlowedCount;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Slow");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("End");

		protected override string Name => "Time Slowdown";

		public static void Init()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			new Hook((MethodBase)typeof(GameManager).GetProperty("TimeSlowed").GetGetMethod(), (Delegate)(Func<Func<GameManager, bool>, GameManager, bool>)((Func<GameManager, bool> orig, GameManager self) => orig(self) && self.timeSlowedCount > _timeSlowedCount));
		}

		protected override void Trigger(string id)
		{
			if (!NoPause)
			{
				_timeSlowedCount++;
			}
			((MonoBehaviour)GameManager.instance).StartCoroutine(GameManager.instance.FreezeMoment(ChangeTime, WaitTime, ReturnTime, TargetSpeed, (Action)delegate
			{
				if (!NoPause)
				{
					_timeSlowedCount--;
				}
				Event("End");
			}));
		}
	}
	public class ToolBlock : ScriptBlock
	{
		public class ToolEvent : MonoBehaviour
		{
			public ToolBlock Block;

			public static readonly List<ToolEvent> Events = new List<ToolEvent>();

			private void OnEnable()
			{
				Events.Add(this);
			}

			private void OnDisable()
			{
				Events.Remove(this);
			}
		}

		public string ToolName;

		public int Amount = 1;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[5] { "ActReset", "AddUses", "TakeUses", "AddLiquid", "TakeLiquid" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnUse");

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Equipped", "Boolean"));

		protected override string Name => "Tool Control";

		public override void Reset()
		{
			ToolName = "";
		}

		public override object GetValue(string id)
		{
			ToolItem byName = ((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).GetByName(ToolName);
			return Object.op_Implicit((Object)(object)byName) && ((ToolBase)byName).IsEquipped;
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ToolEvent toolEvent = new GameObject("[Architect] Receive Block").AddComponent<ToolEvent>();
			toolEvent.Block = this;
		}

		protected override void Trigger(string trigger)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			ToolItem byName = ((NamedScriptableObjectList<ToolItem>)(object)ManagerSingleton<ToolItemManager>.Instance.toolItems).GetByName(ToolName);
			switch (trigger)
			{
			case "ActReset":
				ToolItemManager.AutoEquip(ToolItemManager.GetCrestByName(PlayerData.instance.CurrentCrestID), false, true);
				break;
			case "AddUses":
				if (Object.op_Implicit((Object)(object)byName))
				{
					Data savedData = byName.SavedData;
					savedData.AmountLeft += Amount;
					byName.SavedData = savedData;
					ToolItemManager.ReportAllBoundAttackToolsUpdated();
				}
				break;
			case "TakeUses":
				if (Object.op_Implicit((Object)(object)byName))
				{
					Data savedData2 = byName.SavedData;
					savedData2.AmountLeft += Amount;
					byName.SavedData = savedData2;
					ToolItemManager.ReportAllBoundAttackToolsUpdated();
				}
				break;
			case "AddLiquid":
			{
				if (!Object.op_Implicit((Object)(object)byName))
				{
					break;
				}
				ToolItemStatesLiquid val2 = (ToolItemStatesLiquid)(object)((byName is ToolItemStatesLiquid) ? byName : null);
				if (val2 == null)
				{
					break;
				}
				Data liquidSavedData2 = val2.LiquidSavedData;
				int num2 = Amount;
				if (liquidSavedData2.RefillsLeft + num2 > val2.refillsMax)
				{
					num2 = val2.refillsMax - liquidSavedData2.RefillsLeft;
				}
				LiquidReserveCounter currencyCounter2 = LiquidReserveCounter.GetCurrencyCounter(val2, true);
				if (Object.op_Implicit((Object)(object)currencyCounter2))
				{
					((CurrencyCounterBase)currencyCounter2).IconOverride = null;
					if (Object.op_Implicit((Object)(object)currencyCounter2.infiniteIcon))
					{
						((Component)currencyCounter2.infiniteIcon).gameObject.SetActive(false);
					}
					((CurrencyCounterBase)currencyCounter2).QueueAdd(num2);
					liquidSavedData2.RefillsLeft += num2;
					val2.LiquidSavedData = liquidSavedData2;
				}
				break;
			}
			case "TakeLiquid":
			{
				if (!Object.op_Implicit((Object)(object)byName))
				{
					break;
				}
				ToolItemStatesLiquid val = (ToolItemStatesLiquid)(object)((byName is ToolItemStatesLiquid) ? byName : null);
				if (val == null)
				{
					break;
				}
				Data liquidSavedData = val.LiquidSavedData;
				int num = Amount;
				if (liquidSavedData.RefillsLeft - num < 0)
				{
					num = liquidSavedData.RefillsLeft;
				}
				LiquidReserveCounter currencyCounter = LiquidReserveCounter.GetCurrencyCounter(val, true);
				if (Object.op_Implicit((Object)(object)currencyCounter))
				{
					((CurrencyCounterBase)currencyCounter).IconOverride = null;
					if (Object.op_Implicit((Object)(object)currencyCounter.infiniteIcon))
					{
						((Component)currencyCounter.infiniteIcon).gameObject.SetActive(false);
					}
					((CurrencyCounterBase)currencyCounter).QueueTake(num);
					liquidSavedData.RefillsLeft -= num;
					val.LiquidSavedData = liquidSavedData;
				}
				break;
			}
			}
		}

		public static void DoBroadcast(string tool)
		{
			foreach (ToolEvent item in ToolEvent.Events.Where((ToolEvent e) => e.Block.ToolName == tool))
			{
				item.Block.Event("OnUse");
			}
		}
	}
	public class TransitionBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <Coroutine>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public TransitionBlock <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = HeroController.instance.FreeControl();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					GameManager.instance.BeginSceneTransition(new SceneLoadInfo
					{
						SceneName = <>4__this.Scene,
						EntryGateName = <>4__this.Door,
						EntryDelay = 0f,
						Visualization = (SceneLoadVisualizations)0,
						PreventCameraFadeOut = true,
						WaitForSceneTransitionCameraFade = false
					});
					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 string Scene = "Tut_01";

		public string Door = "placeholder";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Transition");

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("InScene", "Boolean"));

		protected override string Name => "Scene Transition";

		public override object GetValue(string id)
		{
			return Scene == GameManager.instance.sceneName;
		}

		protected override void Trigger(string trigger)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Coroutine());
		}

		[IteratorStateMachine(typeof(<Coroutine>d__10))]
		private IEnumerator Coroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Coroutine>d__10(0)
			{
				<>4__this = this
			};
		}
	}
	public class TravelBlock : CollectionBlock<TravelBlock.TravelLoc>
	{
		public class TravelBtn : MonoBehaviour
		{
			public TravelLoc Block;

			public FastTravelLocations loc;

			public FastTravelMapPiece piece;
		}

		public class TravelLoc : ChildBlock
		{
			public string ListName = "Sample Text";

			public float XPos;

			public float YPos;

			protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Unlocked", "Boolean"));

			protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnChoose");

			public bool Unlocked => GetVariable<bool>("Unlocked", true);

			public override void Reset()
			{
				ListName = "Sample Text";
				XPos = -99999f;
				YPos = -99999f;
			}
		}

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

			private object <>2__current;

			public TravelBlock <>4__this;

			private SetTextMeshProGameText <setTitle>5__1;

			private bool <hasSet>5__2;

			private int <i>5__3;

			private MenuButtonIcon[] <>s__4;

			private int <>s__5;

			private MenuButtonIcon <icon>5__6;

			private IEnumerator<TravelLoc> <>s__7;

			private TravelLoc <travelLoc>5__8;

			private UISelectionListItem <obj>5__9;

			private TravelBtn <btn>5__10;

			private SetTextMeshProGameText <set>5__11;

			private UISelectionListItem <obj>5__12;

			private TravelBtn <btn>5__13;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<setTitle>5__1 = null;
				<>s__4 = null;
				<icon>5__6 = null;
				<>s__7 = null;
				<travelLoc>5__8 = null;
				<obj>5__9 = null;
				<btn>5__10 = null;
				<set>5__11 = null;
				<obj>5__12 = null;
				<btn>5__13 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_032d: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>s__4 = ((Component)_ftm).GetComponentsInChildren<MenuButtonIcon>();
					for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
					{
						<icon>5__6 = <>s__4[<>s__5];
						((ActionButtonIconBase)<icon>5__6).uibs = UIManager.instance.uiButtonSkins;
						<icon>5__6 = null;
					}
					<>s__4 = null;
					<setTitle>5__1 = ((Component)((Component)_ftm).transform.Find("Station List").Find("List").Find("Title Box")
						.Find("Title")).GetComponent<SetTextMeshProGameText>();
					<setTitle>5__1.text = new LocalisedString("ArchitectMod", <>4__this.Title);
					<setTitle>5__1.setTextOn.text = <>4__this.Title;
					_map.sprite = <>4__this.GetVariable<Sprite>("Map");
					_top.sprite = <>4__this.GetVariable<Sprite>("Top");
					((Component)((Component)_ftm).transform.GetChild(0).GetChild(1)).gameObject.SetActive(!Object.op_Implicit((Object)(object)_top.sprite));
					_bot.sprite = <>4__this.GetVariable<Sprite>("Bottom");
					((Component)((Component)_ftm).transform.GetChild(0).GetChild(0)).gameObject.SetActive(!Object.op_Implicit((Object)(object)_bot.sprite));
					<hasSet>5__2 = false;
					<i>5__3 = 0;
					<>s__7 = <>4__this.Children.Children.GetEnumerator();
					try
					{
						while (<>s__7.MoveNext())
						{
							<travelLoc>5__8 = <>s__7.Current;
							<obj>5__9 = ((FastTravelMapBase<FastTravelLocations>)(object)_ftm).list.listItems[<i>5__3];
							<btn>5__10 = ((Component)<obj>5__9).GetComponent<TravelBtn>();
							<btn>5__10.Block = <travelLoc>5__8;
							if (<travelLoc>5__8 == null || !<travelLoc>5__8.Unlocked)
							{
								<i>5__3++;
								continue;
							}
							((Component)<btn>5__10.piece).transform.localPosition = Vector3.zero;
							((FastTravelMapPieceBase<FastTravelMapButton, FastTravelMap, FastTravelLocations>)(object)<btn>5__10.piece).indicatorOffset = new Vector2(<travelLoc>5__8.XPos, <travelLoc>5__8.YPos);
							<set>5__11 = ((Component)<obj>5__9).GetComponent<SetTextMeshProGameText>();
							<set>5__11.text = new LocalisedString("ArchitectMod", <travelLoc>5__8.ListName);
							<set>5__11.setTextOn.text = <travelLoc>5__8.ListName;
							if (!<hasSet>5__2)
							{
								<hasSet>5__2 = true;
								((FastTravelMapBase<FastTravelLocations>)(object)_ftm).AutoSelectLocation = <btn>5__10.loc;
							}
							<i>5__3++;
							<obj>5__9 = null;
							<btn>5__10 = null;
							<set>5__11 = null;
							<travelLoc>5__8 = null;
						}
					}
					finally
					{
						if (<>s__7 != null)
						{
							<>s__7.Dispose();
						}
					}
					<>s__7 = null;
					while (<i>5__3 < 12)
					{
						<obj>5__12 = ((FastTravelMapBase<FastTravelLocations>)(object)_ftm).list.listItems[<i>5__3];
						<btn>5__13 = ((Component)<obj>5__12).GetComponent<TravelBtn>();
						<btn>5__13.Block = null;
						<obj>5__12 = null;
						<btn>5__13 = null;
						<i>5__3++;
					}
					if (!<hasSet>5__2)
					{
						return false;
					}
					<>2__current = HeroController.instance.FreeControl((HeroController _) => !GameManager.instance.isPaused);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					PlayerData.instance.disablePause = true;
					((FastTravelMapBase<FastTravelLocations>)(object)_ftm).Open();
					((Component)((Component)_ftm).transform.GetChild(1).GetChild(0)).gameObject.SetActive(false);
					((Component)((Component)_ftm).transform.GetChild(1).GetChild(2)).gameObject.SetActive(false);
					((FastTravelMapBase<FastTravelLocations>)(object)_ftm).LocationConfirmed += <>4__this.<Coroutine>g__Dismiss|22_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();
			}
		}

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RegainControl();
					PlayerData.instance.disablePause = false;
					return false;
				}
			}

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

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

		private static FastTravelMap _ftm;

		private static SpriteRenderer _map;

		private static SpriteRenderer _top;

		private static SpriteRenderer _bot;

		public string Title;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Display");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnDismiss");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[3]
		{
			("Map", "Sprite"),
			("Top", "Sprite"),
			("Bottom", "Sprite")
		});

		protected override string Name => "Travel UI";

		protected override string ChildName => "Travel Target";

		protected override int MaxChildren => 12;

		protected override bool NeedsGap => true;

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_areabellway", "Assets/Prefabs/UI/Fast Travel Map.prefab", delegate(GameObject o)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0242: Unknown result type (might be due to invalid IL or missing references)
				o = Object.Instantiate<GameObject>(o);
				Object.DontDestroyOnLoad((Object)(object)o);
				o.transform.position = Vector3.zero;
				Object.Destroy((Object)(object)((Component)o.transform.GetChild(3).GetChild(0)).gameObject);
				_ftm = o.GetComponent<FastTravelMap>();
				ConstrainPosition val = ((Component)o.transform.GetChild(1)).gameObject.AddComponent<ConstrainPosition>();
				val.constrainX = true;
				val.constrainY = true;
				_map = Object.Instantiate<GameObject>(((Component)o.transform.Find("backing")).gameObject).GetComponent<SpriteRenderer>();
				((Component)_map).transform.parent = o.transform;
				((Object)_map).name = "Map";
				((Component)_map).transform.localScale = Vector3.one;
				((Component)_map).transform.position = new Vector3(-6f, 0f, 2f);
				_top = Object.Instantiate<GameObject>(((Component)o.transform.Find("backing")).gameObject).GetComponent<SpriteRenderer>();
				((Component)_top).transform.parent = o.transform;
				((Object)_top).name = "Top";
				((Component)_top).transform.localScale = Vector3.one;
				((Component)_top).transform.position = new Vector3(0f, 6.9173f, 2f);
				_bot = Object.Instantiate<GameObject>(((Component)o.transform.Find("backing")).gameObject).GetComponent<SpriteRenderer>();
				((Component)_bot).transform.parent = o.transform;
				((Object)_bot).name = "Bottom";
				((Component)_bot).transform.localScale = Vector3.one;
				((Component)_bot).transform.position = new Vector3(0f, -6.7024f, 2f);
				FastTravelMapButton[] componentsInChildren = o.GetComponentsInChildren<FastTravelMapButton>();
				foreach (FastTravelMapButton btn in componentsInChildren)
				{
					((FastTravelMapButtonBase<FastTravelLocations>)(object)btn).playerDataBool = "";
					TravelBtn travelBtn = ((Component)btn).gameObject.AddComponent<TravelBtn>();
					travelBtn.loc = ((FastTravelMapButtonBase<FastTravelLocations>)(object)btn).targetLocation;
					FastTravelMapPiece piece2 = o.GetComponentsInChildren<FastTravelMapPiece>().First((FastTravelMapPiece piece) => (Object)(object)((FastTravelMapPieceBase<FastTravelMapButton, FastTravelMap, FastTravelLocations>)(object)piece).pairedButton == (Object)(object)btn);
					travelBtn.piece = piece2;
				}
			}, notSceneBundle: true));
			typeof(FastTravelMapButtonBase<FastTravelLocations>).Hook("IsUnlocked", (Func<Func<FastTravelMapButtonBase<FastTravelLocations>, bool>, FastTravelMapButtonBase<FastTravelLocations>, bool>)delegate(Func<FastTravelMapButtonBase<FastTravelLocations>, bool> orig, FastTravelMapButtonBase<FastTravelLocations> self)
			{
				TravelBtn component2 = ((Component)self).GetComponent<TravelBtn>();
				return Object.op_Implicit((Object)(object)component2) ? (component2.Block?.Unlocked ?? false) : orig(self);
			});
			typeof(FastTravelMapButtonBase<FastTravelLocations>).Hook("Submit", (Action<Action<FastTravelMapButtonBase<FastTravelLocations>>, FastTravelMapButtonBase<FastTravelLocations>>)delegate(Action<FastTravelMapButtonBase<FastTravelLocations>> orig, FastTravelMapButtonBase<FastTravelLocations> self)
			{
				TravelBtn component = ((Component)self).GetComponent<TravelBtn>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.Block.Event("OnChoose");
				}
				orig(self);
			});
		}

		public override void Reset()
		{
			Title = "Sample Text";
		}

		protected override void Trigger(string trigger)
		{
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Coroutine());
		}

		[IteratorStateMachine(typeof(<Coroutine>d__22))]
		private IEnumerator Coroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Coroutine>d__22(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<RegainControlDelayed>d__23))]
		private static IEnumerator RegainControlDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RegainControlDelayed>d__23(0);
		}
	}
	public class UIBlock : ScriptBlock
	{
		public float Duration = 1f;

		public float R = 1f;

		public float G = 1f;

		public float B = 1f;

		public float A = 1f;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[7] { "HudIn", "HudOut", "FadeIn", "FadeOut", "CloseInventory", "MemoryBlur", "ClearBlur" });

		protected override string Name => "UI Control";

		public override void Reset()
		{
			Duration = 1f;
			R = 1f;
			G = 1f;
			B = 1f;
			A = 1f;
		}

		protected override void Trigger(string id)
		{
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			switch (id)
			{
			case "HudIn":
				GameCameras.instance.HUDIn();
				break;
			case "HudOut":
				GameCameras.instance.HUDOut();
				break;
			case "FadeIn":
				ScreenFaderUtils.Fade(new Color(R, G, B, A), Color.clear, Duration);
				break;
			case "FadeOut":
				ScreenFaderUtils.Fade(Color.clear, new Color(R, G, B, A), Duration);
				break;
			case "CloseInventory":
				EventRegister.SendEvent(EventRegisterEvents.InventoryCancel, (GameObject)null);
				break;
			case "MemoryBlur":
				CameraBlurPlane.MaskLerp = 1f;
				CameraBlurPlane.MaskScale = 2f;
				CameraBlurPlane.Spacing = 30f;
				break;
			case "ClearBlur":
				CameraBlurPlane.MaskLerp = 0f;
				CameraBlurPlane.MaskScale = 0f;
				CameraBlurPlane.Spacing = 0f;
				break;
			}
		}
	}
}
namespace Architect.Events.Blocks.Operators
{
	public class CompareBlock : ScriptBlock
	{
		public int Mode;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("1", "Number"),
			("2", "Number")
		});

		protected override string Name => "Compare";

		public override object GetValue(string id)
		{
			float variable = GetVariable<float>("1");
			float variable2 = GetVariable<float>("2");
			int mode = Mode;
			if (1 == 0)
			{
			}
			bool flag = mode switch
			{
				0 => Mathf.Approximately(variable, variable2), 
				1 => variable > variable2, 
				2 => variable < variable2, 
				3 => variable >= variable2, 
				_ => variable <= variable2, 
			};
			if (1 == 0)
			{
			}
			return flag;
		}
	}
	public class StringCompareBlock : ScriptBlock
	{
		public int Mode;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("1", "Text"),
			("2", "Text")
		});

		protected override string Name => "Compare Text";

		public override object GetValue(string id)
		{
			string variable = GetVariable<string>("1");
			string variable2 = GetVariable<string>("2");
			int mode = Mode;
			if (1 == 0)
			{
			}
			bool flag = mode switch
			{
				0 => variable == variable2, 
				1 => variable.Contains(variable2), 
				2 => variable.StartsWith(variable2), 
				3 => variable.EndsWith(variable2), 
				_ => variable.Length > variable2.Length, 
			};
			if (1 == 0)
			{
			}
			return flag;
		}
	}
	public abstract class ConstantBlock : ScriptBlock
	{
		public bool Public;

		public string ConfigName;

		public abstract Architect.Config.Types.ConfigType GetConfigType();

		public abstract void Load(string value);
	}
	public class ConstantNumBlock : ConstantBlock
	{
		public float Value;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override string Name => "Constant (Number)";

		public override object GetValue(string id)
		{
			return Value;
		}

		public override Architect.Config.Types.ConfigType GetConfigType()
		{
			return Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType(ConfigName, "prefab_config_" + BlockId, delegate(GameObject o, FloatConfigValue f)
			{
				o.GetComponent<Prefab>().ApplyConfig(BlockId, f.SerializeValue());
			}).WithDefaultValue(Value));
		}

		public override void Load(string value)
		{
			float.TryParse(value, out Value);
		}
	}
	public class ConstantBoolBlock : ConstantBlock
	{
		public bool Value;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override string Name => "Constant (Bool)";

		public override object GetValue(string id)
		{
			return Value;
		}

		public override Architect.Config.Types.ConfigType GetConfigType()
		{
			return Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType(ConfigName, "prefab_config_" + BlockId, delegate(GameObject o, BoolConfigValue f)
			{
				o.GetComponent<Prefab>().ApplyConfig(BlockId, f.SerializeValue());
			}).WithDefaultValue(Value));
		}

		public override void Load(string value)
		{
			bool.TryParse(value, out Value);
		}
	}
	public class ConstantTextBlock : ConstantBlock
	{
		public string Value = string.Empty;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Text"));

		protected override string Name => "Constant (Text)";

		public override object GetValue(string id)
		{
			return Value;
		}

		public override Architect.Config.Types.ConfigType GetConfigType()
		{
			return Architect.Config.ConfigurationManager.RegisterConfigType(new StringConfigType(ConfigName, "prefab_config_" + BlockId, delegate(GameObject o, StringConfigValue f)
			{
				o.GetComponent<Prefab>().ApplyConfig(BlockId, f.SerializeValue());
			}).WithDefaultValue(Value));
		}

		public override void Load(string value)
		{
			Value = value;
		}
	}
	public class ConvertBlock : ScriptBlock
	{
		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Any"));

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[3]
		{
			("ToText", "Text"),
			("ToNum", "Number"),
			("ToBool", "Boolean")
		});

		protected override string Name => "Convert";

		public override object GetValue(string id)
		{
			string text = GetVariable<object>("Value").ToString();
			if (1 == 0)
			{
			}
			bool result;
			float result2;
			bool result3;
			float result4;
			object result5 = id switch
			{
				"ToText" => text, 
				"ToBool" => (bool.TryParse(text, out result) || (float.TryParse(text, out result2) && result2 > 0f)) && result, 
				"ToNum" => bool.TryParse(text, out result3) ? ((float)(result3 ? 1 : 0)) : (float.TryParse(text, out result4) ? result4 : 0f), 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			return result5;
		}
	}
	public class CounterBlock : ScriptBlock
	{
		public int Count;

		private int _count;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "In", "Reset" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Out");

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Count", "Number"));

		protected override string Name => "Counter";

		public override void SetupReference()
		{
			_count = 0;
		}

		public override object GetValue(string id)
		{
			return _count;
		}

		protected override void Trigger(string trigger)
		{
			if (trigger == "Reset")
			{
				_count = 0;
				return;
			}
			_count++;
			if (_count >= Count)
			{
				_count = 0;
				Event("Out");
			}
		}
	}
	public class CustomNeedleBlock : ScriptBlock
	{
		public string Value;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Set", "Clear" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Text"));

		protected override string Name => "Custom Needle Control";

		protected override void Trigger(string trigger)
		{
			ArchitectData.Instance.CustomNeedle = ((trigger == "Set") ? Value : string.Empty);
		}

		public override object GetValue(string id)
		{
			return ArchitectData.Instance.CustomNeedle;
		}
	}
	public class DelayBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <DelayedEvent>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DelayBlock <>4__this;

			private float <delay>5__1;

			private DelayObj <d>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<delay>5__1 = <>4__this.Delay;
					<d>5__2 = <>4__this._delay;
					<delay>5__1 += <>4__this.GetVariable<float>("Extra Delay");
					<>2__current = (object)new WaitForSeconds(<delay>5__1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (Object.op_Implicit((Object)(object)<d>5__2))
					{
						<>4__this.Event("Out");
					}
					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 float Delay;

		private DelayObj _delay;

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Extra Delay", "Number"));

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "In", "Cancel" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Out");

		protected override string Name => "Delay";

		public override void Reset()
		{
			Delay = 0f;
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("[Architect] Delay Block");
			_delay = val.AddComponent<DelayObj>();
		}

		protected override void Trigger(string trigger)
		{
			if (Object.op_Implicit((Object)(object)_delay))
			{
				if (trigger == "In")
				{
					((MonoBehaviour)_delay).StartCoroutine(DelayedEvent());
				}
				else
				{
					((MonoBehaviour)_delay).StopAllCoroutines();
				}
			}
		}

		[IteratorStateMachine(typeof(<DelayedEvent>d__13))]
		private IEnumerator DelayedEvent()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedEvent>d__13(0)
			{
				<>4__this = this
			};
		}
	}
	public class WaitUntilBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <DelayedEvent>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public WaitUntilBlock <>4__this;

			private DelayObj <d>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<d>5__1 = <>4__this._delay;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>4__this.GetVariable<bool>("Check")));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (Object.op_Implicit((Object)(object)<d>5__1))
					{
						<>4__this.Event("Out");
					}
					return false;
				}
			}

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

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

		private DelayObj _delay;

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Check", "Boolean"));

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "In", "Cancel" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Out");

		protected override string Name => "Wait Until";

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("[Architect] Wait Until Block");
			_delay = val.AddComponent<DelayObj>();
		}

		protected override void Trigger(string trigger)
		{
			if (Object.op_Implicit((Object)(object)_delay))
			{
				if (trigger == "In")
				{
					((MonoBehaviour)_delay).StartCoroutine(DelayedEvent());
				}
				else
				{
					((MonoBehaviour)_delay).StopAllCoroutines();
				}
			}
		}

		[IteratorStateMachine(typeof(<DelayedEvent>d__11))]
		private IEnumerator DelayedEvent()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedEvent>d__11(0)
			{
				<>4__this = this
			};
		}
	}
	public class LoopBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <DelayedEvent>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LoopBlock <>4__this;

			private DelayObj <d>5__1;

			private int <times>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0098;
				}
				<>1__state = -1;
				<d>5__1 = <>4__this._delay;
				<times>5__2 = Mathf.RoundToInt(<>4__this.GetVariable<float>("Times"));
				<>4__this._currentTime = 0;
				goto IL_00d6;
				IL_0098:
				if (!Object.op_Implicit((Object)(object)<d>5__1))
				{
					return false;
				}
				<>4__this.Event("Out");
				<>4__this._currentTime++;
				goto IL_00d6;
				IL_00d6:
				if (<>4__this._currentTime < <times>5__2)
				{
					if (<>4__this.Delay > 0f)
					{
						<>2__current = (object)new WaitForSeconds(<>4__this.Delay);
						<>1__state = 1;
						return true;
					}
					goto IL_0098;
				}
				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 float Delay;

		private int _currentTime;

		private DelayObj _delay;

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Times", "Number"));

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Loop Value", "Number"));

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "In", "Cancel" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Out");

		protected override string Name => "Loop";

		public override void Reset()
		{
			Delay = 0f;
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("[Architect] Delay Block");
			_delay = val.AddComponent<DelayObj>();
		}

		protected override void Trigger(string trigger)
		{
			if (Object.op_Implicit((Object)(object)_delay))
			{
				if (trigger == "In")
				{
					((MonoBehaviour)_delay).StartCoroutine(DelayedEvent());
				}
				else
				{
					((MonoBehaviour)_delay).StopAllCoroutines();
				}
			}
		}

		public override object GetValue(string id)
		{
			return _currentTime;
		}

		[IteratorStateMachine(typeof(<DelayedEvent>d__17))]
		private IEnumerator DelayedEvent()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedEvent>d__17(0)
			{
				<>4__this = this
			};
		}
	}
	public class DelayObj : MonoBehaviour
	{
	}
	public class NotBlock : ScriptBlock
	{
		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override string Name => "Not";

		public override object GetValue(string id)
		{
			return !GetVariable<bool>("Value");
		}
	}
	public class AndBlock : ScriptBlock
	{
		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("1", "Boolean"),
			("2", "Boolean")
		});

		protected override string Name => "And";

		public override object GetValue(string id)
		{
			return GetVariable<bool>("1") && GetVariable<bool>("2");
		}
	}
	public class OrBlock : ScriptBlock
	{
		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("1", "Boolean"),
			("2", "Boolean")
		});

		protected override string Name => "Or";

		public override object GetValue(string id)
		{
			return GetVariable<bool>("1") || GetVariable<bool>("2");
		}
	}
	public class IfBlock : ScriptBlock
	{
		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("In");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[2] { "True", "False" });

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Check", "Boolean"));

		protected override string Name => "If";

		protected override void Trigger(string trigger)
		{
			Event(GetVariable<bool>("Check") ? "True" : "False");
		}
	}
	public class MathsBlock : ScriptBlock
	{
		public int Mode;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("1", "Number"),
			("2", "Number")
		});

		protected override string Name => "Operation";

		public override object GetValue(string id)
		{
			float variable = GetVariable<float>("1");
			float variable2 = GetVariable<float>("2");
			int mode = Mode;
			if (1 == 0)
			{
			}
			float num = mode switch
			{
				0 => variable + variable2, 
				1 => variable - variable2, 
				2 => variable * variable2, 
				3 => variable / variable2, 
				4 => Mathf.Floor(variable / variable2), 
				5 => variable % variable2, 
				6 => Mathf.Pow(variable, variable2), 
				7 => Mathf.Pow(variable, 1f / variable2), 
				8 => Mathf.Min(variable, variable2), 
				_ => Mathf.Max(variable, variable2), 
			};
			if (1 == 0)
			{
			}
			return num;
		}
	}
	public class TrigBlock : ScriptBlock
	{
		public int Mode;

		public bool IsDegrees;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override string Name => "Trig Operation";

		public override object GetValue(string id)
		{
			float variable = GetVariable<float>("Value");
			int mode = Mode;
			if (1 == 0)
			{
			}
			float num = mode switch
			{
				0 => Mathf.Sin(variable * (IsDegrees ? (MathF.PI / 180f) : 1f)), 
				1 => Mathf.Cos(variable * (IsDegrees ? (MathF.PI / 180f) : 1f)), 
				2 => Mathf.Tan(variable * (IsDegrees ? (MathF.PI / 180f) : 1f)), 
				3 => Mathf.Asin(variable) * (IsDegrees ? 57.29578f : 1f), 
				4 => Mathf.Acos(variable) * (IsDegrees ? 57.29578f : 1f), 
				_ => Mathf.Atan(variable) * (IsDegrees ? 57.29578f : 1f), 
			};
			if (1 == 0)
			{
			}
			return num;
		}
	}
	public class NormaliseBlock : ScriptBlock
	{
		public float Angle;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("X", "Number"),
			("Y", "Number")
		});

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("X", "Number"),
			("Y", "Number")
		});

		protected override string Name => "Normalise";

		public override void Reset()
		{
			Angle = 0f;
		}

		public override object GetValue(string id)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			float variable = GetVariable<float>("X");
			float variable2 = GetVariable<float>("Y");
			Quaternion val = Quaternion.Euler(0f, 0f, Angle);
			Vector2 val2 = new Vector2(variable, variable2);
			Vector3 val3 = val * Vector2.op_Implicit(((Vector2)(ref val2)).normalized);
			return (id == "X") ? val3.x : val3.y;
		}
	}
	public class OneByOneBlock : CollectionBlock<OneByOneBlock.TriggerBlock>
	{
		public class TriggerBlock : ChildBlock
		{
			public bool Enabled = true;

			protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Disable", "Enable" });

			protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnTrigger");

			public override void Reset()
			{
				Enabled = true;
			}

			protected override void Trigger(string trigger)
			{
				Enabled = trigger == "Enable";
			}
		}

		private int _index;

		protected override string Name => "Step Counter";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "Trigger", "DisableAll", "EnableAll" });

		protected override string ChildName => "Step Trigger";

		protected override bool NeedsGap => false;

		public override void Reset()
		{
			_index = 0;
		}

		protected override void Trigger(string trigger)
		{
			if (Children.Children.Count((TriggerBlock c) => c.Enabled) != 0)
			{
				int count = Children.Blocks.Count;
				_index %= count;
				Children.Blocks[_index].Event("OnTrigger");
				do
				{
					_index++;
					_index %= count;
				}
				while (!(Children.Blocks[_index] as TriggerBlock).Enabled);
			}
		}
	}
	public static class OperatorBlocks
	{
		public static void Init()
		{
			Category.Logic.RegisterBlock<IfBlock>("If");
			Category.Logic.RegisterBlock<CompareBlock>("Compare", Architect.Events.Blocks.Config.ConfigGroup.Compare);
			Category.Logic.RegisterBlock<StringCompareBlock>("Compare Text", Architect.Events.Blocks.Config.ConfigGroup.StringCompare);
			Category.Logic.RegisterBlock<OrderBlock>("Ordered Events");
			Category.Logic.RegisterHiddenBlock<OrderBlock.TriggerBlock>("Order Trigger");
			Category.Logic.RegisterBlock<RandomEventBlock>("Random Event");
			Category.Logic.RegisterHiddenBlock<RandomEventBlock.TriggerBlock>("Random Trigger", Architect.Events.Blocks.Config.ConfigGroup.RandomTrigger);
			Category.Logic.RegisterBlock<CounterBlock>("Counter", Architect.Events.Blocks.Config.ConfigGroup.Counter);
			Category.Logic.RegisterBlock<OneByOneBlock>("Step Counter");
			Category.Logic.RegisterHiddenBlock<OneByOneBlock.TriggerBlock>("Step Trigger");
			Category.Data.RegisterBlock<ConstantNumBlock>("Constant Num", Architect.Events.Blocks.Config.ConfigGroup.ConstantNum);
			Category.Data.RegisterBlock<ConstantBoolBlock>("Constant Bool", Architect.Events.Blocks.Config.ConfigGroup.ConstantBool);
			Category.Data.RegisterBlock<ConstantTextBlock>("Constant Text", Architect.Events.Blocks.Config.ConfigGroup.ConstantText);
			Category.Data.RegisterBlock<BoolVarBlock>("Variable (Bool)", Architect.Events.Blocks.Config.ConfigGroup.BoolVar, BoolVarBlock.Init);
			Category.Data.RegisterBlock<NumVarBlock>("Variable (Number)", Architect.Events.Blocks.Config.ConfigGroup.NumVar, NumVarBlock.Init);
			Category.Data.RegisterBlock<StringVarBlock>("Variable (Text)", Architect.Events.Blocks.Config.ConfigGroup.StringVar, StringVarBlock.Init);
			Category.Data.RegisterBlock<ConvertBlock>("Convert");
			Category.Data.RegisterBlock<RandomNumBlock>("Random Number", Architect.Events.Blocks.Config.ConfigGroup.RandomNumber);
			Category.Data.RegisterBlock<RandomBoolBlock>("Random Bool");
			Category.Data.RegisterBlock<RandomTextBlock>("Random Text", Architect.Events.Blocks.Config.ConfigGroup.RandomText);
			Category.Data.RegisterBlock<MathsBlock>("Operation", Architect.Events.Blocks.Config.ConfigGroup.Maths);
			Category.Data.RegisterBlock<TrigBlock>("Trig Operation", Architect.Events.Blocks.Config.ConfigGroup.Trig);
			Category.Data.RegisterBlock<NormaliseBlock>("Normalise", Architect.Events.Blocks.Config.ConfigGroup.Normalise);
			Category.World.RegisterBlock<RaycastBlock>("Raycast", Architect.Events.Blocks.Config.ConfigGroup.Raycast);
			Category.World.RegisterHiddenBlock<SceneNameBlock>("Scene Name");
			Category.World.RegisterHiddenBlock<GameplayBlock>("Gameplay");
			Category.Logic.RegisterBlock<AndBlock>("And");
			Category.Logic.RegisterBlock<OrBlock>("Or");
			Category.Logic.RegisterBlock<NotBlock>("Not");
			Category.Time.RegisterBlock<DelayBlock>("Delay", Architect.Events.Blocks.Config.ConfigGroup.Delay);
			Category.Time.RegisterBlock<WaitUntilBlock>("Wait Until");
			Category.Time.RegisterBlock<LoopBlock>("Loop", Architect.Events.Blocks.Config.ConfigGroup.Loop);
			Category.Time.RegisterBlock<TimeBlock>("Time", Architect.Events.Blocks.Config.ConfigGroup.Time);
			Category.Time.RegisterBlock<DayBlock>("Day", Architect.Events.Blocks.Config.ConfigGroup.Time);
			Category.Data.RegisterBlock<PersistentBoolBlock>("Persistent Data", Architect.Events.Blocks.Config.ConfigGroup.Pd);
			Category.Data.RegisterBlock<PlayerDataBoolBlock>("PlayerData (Bool)", Architect.Events.Blocks.Config.ConfigGroup.PdBool, PlayerDataBoolBlock.Init);
			Category.Data.RegisterBlock<PlayerDataIntBlock>("PlayerData (Int)", Architect.Events.Blocks.Config.ConfigGroup.PdInt);
			Category.Data.RegisterBlock<PlayerDataFloatBlock>("PlayerData (Float)", Architect.Events.Blocks.Config.ConfigGroup.PdFloat);
			Category.World.RegisterBlock<CustomNeedleBlock>("Custom Needle", Architect.Events.Blocks.Config.ConfigGroup.CustomNeedle);
		}
	}
	public class OrderBlock : CollectionBlock<OrderBlock.TriggerBlock>
	{
		public class TriggerBlock : ChildBlock
		{
			public bool Enabled = true;

			protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Disable", "Enable" });

			protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnTrigger");

			public override void Reset()
			{
				Enabled = true;
			}

			protected override void Trigger(string trigger)
			{
				Enabled = trigger == "Enable";
			}
		}

		protected override string Name => "Ordered Events";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "Trigger", "DisableAll", "EnableAll" });

		protected override string ChildName => "Order Trigger";

		protected override bool NeedsGap => false;

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "Trigger":
			{
				TriggerBlock[] array = Children.Children.Where((TriggerBlock b) => b.Enabled).ToArray();
				TriggerBlock[] array2 = array;
				foreach (TriggerBlock triggerBlock in array2)
				{
					triggerBlock.Event("OnTrigger");
				}
				break;
			}
			case "DisableAll":
			{
				foreach (TriggerBlock child in Children.Children)
				{
					child.Enabled = false;
				}
				break;
			}
			case "EnableAll":
			{
				foreach (TriggerBlock child2 in Children.Children)
				{
					child2.Enabled = true;
				}
				break;
			}
			}
		}
	}
	public class PlayerDataBoolBlock : ScriptBlock
	{
		public class BoolBlockRef : MonoBehaviour
		{
			public PlayerDataBoolBlock Block;

			private void OnDisable()
			{
				BlockRefs[Block.Data].Remove(this);
			}
		}

		private static readonly Dictionary<string, List<BoolBlockRef>> BlockRefs = new Dictionary<string, List<BoolBlockRef>>();

		public string Data = string.Empty;

		public bool Value;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Set");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[2] { "OnTrue", "OnFalse" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override string Name => "PlayerData Control (Bool)";

		public static void Init()
		{
			PlayerDataVariableEvents.OnSetBool += delegate(PlayerData _, string name, bool current)
			{
				if (!BlockRefs.TryGetValue(name, out var value))
				{
					return current;
				}
				foreach (BoolBlockRef item in value)
				{
					item.Block.Event(current ? "OnTrue" : "OnFalse");
				}
				return current;
			};
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("[Architect] Bool Block");
			BoolBlockRef boolBlockRef = val.AddComponent<BoolBlockRef>();
			boolBlockRef.Block = this;
			if (!BlockRefs.ContainsKey(Data))
			{
				BlockRefs[Data] = new List<BoolBlockRef>();
			}
			BlockRefs[Data].Add(boolBlockRef);
		}

		protected override void Trigger(string trigger)
		{
			PlayerData.instance.SetBool(Data, Value);
		}

		public override object GetValue(string id)
		{
			return PlayerData.instance.GetBool(Data);
		}
	}
	public class PersistentBoolBlock : ScriptBlock
	{
		public string Group;

		public string Data;

		public bool Value;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Set", "ClearScene" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override string Name => "Persistent Data Control";

		protected override void Trigger(string trigger)
		{
			if (trigger == "Set")
			{
				PersistentItemData<bool> val = default(PersistentItemData<bool>);
				if (((PersistentItemDataCollection<bool, SerializableBoolData>)(object)SceneData.instance.persistentBools).TryGetValue(Group, Data, ref val))
				{
					val.Value = Value;
				}
			}
			else
			{
				((PersistentItemDataCollection<bool, SerializableBoolData>)(object)SceneData.instance.persistentBools).scenes.Remove(Group);
			}
		}

		public override object GetValue(string id)
		{
			PersistentItemData<bool> val = default(PersistentItemData<bool>);
			return ((PersistentItemDataCollection<bool, SerializableBoolData>)(object)SceneData.instance.persistentBools).TryGetValue(Group, Data, ref val) && val.Value;
		}
	}
	public class PlayerDataIntBlock : ScriptBlock
	{
		public string Data;

		public int Value;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "Set", "Add", "Subtract" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override string Name => "PlayerData Control (Int)";

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "Set":
				PlayerData.instance.SetInt(Data, Value);
				break;
			case "Add":
				PlayerData.instance.SetInt(Data, PlayerData.instance.GetInt(Data) + Value);
				break;
			case "Subtract":
				PlayerData.instance.SetInt(Data, PlayerData.instance.GetInt(Data) - Value);
				break;
			}
		}

		public override object GetValue(string id)
		{
			return PlayerData.instance.GetInt(Data);
		}
	}
	public class PlayerDataFloatBlock : ScriptBlock
	{
		public string Data;

		public float Value;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "Set", "Add", "Subtract" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override string Name => "PlayerData Control (Float)";

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "Set":
				PlayerData.instance.SetFloat(Data, Value);
				break;
			case "Add":
				PlayerData.instance.SetFloat(Data, PlayerData.instance.GetFloat(Data) + Value);
				break;
			case "Subtract":
				PlayerData.instance.SetFloat(Data, PlayerData.instance.GetFloat(Data) - Value);
				break;
			}
		}

		public override object GetValue(string id)
		{
			return PlayerData.instance.GetFloat(Data);
		}
	}
	public class RandomBoolBlock : ScriptBlock
	{
		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override string Name => "Random (Bool)";

		public override object GetValue(string id)
		{
			return Random.value > 0.5f;
		}
	}
	public class RandomNumBlock : ScriptBlock
	{
		public float LowerBound;

		public float UpperBound;

		public bool WholeNumber;

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override string Name => "Random (Number)";

		public override object GetValue(string id)
		{
			if (UpperBound <= LowerBound)
			{
				return LowerBound;
			}
			return WholeNumber ? ((float)Random.RandomRangeInt(Mathf.CeilToInt(LowerBound), Mathf.FloorToInt(UpperBound) + 1)) : Random.Range(LowerBound, UpperBound);
		}
	}
	public class RandomTextBlock : ScriptBlock
	{
		public string Pool = string.Empty;

		public string Delimiter = ",";

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Text"));

		protected override string Name => "Random (Text)";

		public override object GetValue(string id)
		{
			try
			{
				return Extensions.GetRandomElement<string>(Pool.Split(Delimiter));
			}
			catch (Exception)
			{
				return string.Empty;
			}
		}
	}
	public class RandomEventBlock : CollectionBlock<RandomEventBlock.TriggerBlock>
	{
		public class TriggerBlock : ChildBlock
		{
			public float Chance;

			public bool Enabled = true;

			protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Disable", "Enable" });

			protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnTrigger");

			public override void Reset()
			{
				Enabled = true;
			}

			protected override void Trigger(string trigger)
			{
				Enabled = trigger == "Enable";
			}
		}

		protected override string Name => "Random Event";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "Trigger", "DisableAll", "EnableAll" });

		protected override string ChildName => "Random Trigger";

		protected override bool NeedsGap => false;

		protected override void Trigger(string trigger)
		{
			switch (trigger)
			{
			case "Trigger":
			{
				TriggerBlock[] array = Children.Children.Where((TriggerBlock b) => b.Enabled).ToArray();
				float num = array.Sum((TriggerBlock b) => b.Chance);
				if (num <= 0f)
				{
					break;
				}
				float num2 = Random.Range(0f, num);
				TriggerBlock[] array2 = array;
				foreach (TriggerBlock triggerBlock in array2)
				{
					num2 -= triggerBlock.Chance;
					if (num2 <= 0f)
					{
						triggerBlock.Event("OnTrigger");
						break;
					}
				}
				break;
			}
			case "DisableAll":
			{
				foreach (TriggerBlock child in Children.Children)
				{
					child.Enabled = false;
				}
				break;
			}
			case "EnableAll":
			{
				foreach (TriggerBlock child2 in Children.Children)
				{
					child2.Enabled = true;
				}
				break;
			}
			}
		}
	}
	public class RaycastBlock : ScriptBlock
	{
		public float MaxDistance = 10f;

		public int Mode;

		private bool _hit;

		private float _xHit;

		private float _yHit;

		private float _dist;

		private static readonly int TerrainMask = LayerMask.GetMask(new string[1] { "Terrain" });

		private static readonly int EnemyMask = LayerMask.GetMask(new string[1] { "Enemies" });

		private static readonly int PlayerMask = LayerMask.GetMask(new string[1] { "Player" });

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Raytrace");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[6]
		{
			ScriptBlock.Space,
			ScriptBlock.Space,
			("X Pos", "Number"),
			("Y Pos", "Number"),
			("X Dir", "Number"),
			("Y Dir", "Number")
		});

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[4]
		{
			("Hit", "Boolean"),
			("X", "Number"),
			("Y", "Number"),
			("Distance", "Number")
		});

		protected override string Name => "Raycast";

		public override void Reset()
		{
			Clear();
			MaxDistance = 10f;
			Mode = 0;
		}

		private void Clear()
		{
			_hit = false;
			_xHit = 0f;
			_yHit = 0f;
			_dist = 0f;
		}

		protected override void Trigger(string trigger)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetVariable<float>("X Pos"), GetVariable<float>("Y Pos"));
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(GetVariable<float>("X Dir"), GetVariable<float>("Y Dir"));
			float maxDistance = MaxDistance;
			int mode = Mode;
			if (1 == 0)
			{
			}
			int num = mode switch
			{
				0 => TerrainMask, 
				1 => EnemyMask, 
				_ => PlayerMask, 
			};
			if (1 == 0)
			{
			}
			RaycastHit2D val3 = Physics2D.Raycast(val, val2, maxDistance, num);
			if (!RaycastHit2D.op_Implicit(val3))
			{
				Clear();
				return;
			}
			_hit = true;
			_xHit = ((RaycastHit2D)(ref val3)).point.x;
			_yHit = ((RaycastHit2D)(ref val3)).point.y;
			_dist = ((RaycastHit2D)(ref val3)).distance;
		}

		public override object GetValue(string id)
		{
			if (1 == 0)
			{
			}
			object result = id switch
			{
				"Hit" => _hit, 
				"X" => _xHit, 
				"Y" => _yHit, 
				"Distance" => _dist, 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class SceneNameBlock : TimeBlockType
	{
		protected override string Name => "Scene Name";

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Name", "Text"));

		public override object GetValue(string id)
		{
			return GameManager.instance.sceneName;
		}
	}
	public class GameplayBlock : TimeBlockType
	{
		protected override string Name => "Gameplay Control";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("SetGravity");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("GravX", "Number"),
			("GravY", "Number")
		});

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("Scene", "Text"),
			("Paused", "Boolean")
		});

		protected override void Trigger(string trigger)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Physics2D.gravity = new Vector2(GetVariable<float>("GravX"), GetVariable<float>("GravY", -60));
		}

		public override object GetValue(string id)
		{
			if (id == "Paused")
			{
				return GameManager.instance.isPaused;
			}
			return GameManager.instance.sceneName;
		}
	}
	public abstract class TimeBlockType : ScriptBlock
	{
		public int Mode = 0;

		protected DateTime GetNow()
		{
			return (Mode == 0) ? DateTime.Now : DateTime.UtcNow;
		}
	}
	public class TimeBlock : TimeBlockType
	{
		protected override string Name => "Time Block";

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[5]
		{
			("Days", "Number"),
			("Hours", "Number"),
			("Minutes", "Number"),
			("Seconds", "Number"),
			("Delta", "Number")
		});

		public override object GetValue(string id)
		{
			TimeSpan timeSpan = GetNow() - DateTime.UnixEpoch;
			if (1 == 0)
			{
			}
			double value = id switch
			{
				"Days" => timeSpan.TotalDays, 
				"Hours" => timeSpan.TotalHours, 
				"Minutes" => timeSpan.TotalMinutes, 
				"Seconds" => timeSpan.TotalSeconds, 
				_ => Time.deltaTime, 
			};
			if (1 == 0)
			{
			}
			return Convert.ToSingle(value);
		}
	}
	public class DayBlock : TimeBlockType
	{
		protected override string Name => "Day Block";

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[6]
		{
			("OfYear", "Number"),
			("OfWeek", "Number"),
			("Hour", "Number"),
			("Minute", "Number"),
			("Second", "Number"),
			("Ms", "Number")
		});

		public override object GetValue(string id)
		{
			DateTime now = GetNow();
			if (1 == 0)
			{
			}
			int num = id switch
			{
				"OfYear" => now.DayOfYear, 
				"OfWeek" => (int)now.DayOfWeek, 
				"Hour" => (int)now.TimeOfDay.TotalHours, 
				"Minute" => (int)now.TimeOfDay.TotalMinutes % 60, 
				"Second" => (int)now.TimeOfDay.TotalSeconds % 60, 
				_ => (int)now.TimeOfDay.TotalMilliseconds % 1000, 
			};
			if (1 == 0)
			{
			}
			return num;
		}
	}
	public abstract class VarBlock : LocalBlock
	{
		public string Id = "";

		public abstract string GetTypeId();
	}
	public class BoolVarBlock : VarBlock
	{
		private static readonly Dictionary<string, bool> TempVars = new Dictionary<string, bool>();

		public static readonly Dictionary<string, bool> SemiVars = new Dictionary<string, bool>();

		public int PType;

		public bool Default;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Set");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("New Value", "Boolean"));

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Boolean"));

		protected override string Name => "Variable (Bool)";

		public static void Init()
		{
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				TempVars.Clear();
				if (Settings.TestMode.Value)
				{
					SemiVars.Clear();
					ArchitectData.Instance.BoolVariables.Clear();
				}
			});
		}

		protected override void Trigger(string trigger)
		{
			bool variable = GetVariable<bool>("New Value");
			switch (PType)
			{
			case 0:
				TempVars[Id] = variable;
				break;
			case 1:
				SemiVars[Id] = variable;
				break;
			case 2:
				ArchitectData.Instance.BoolVariables[Id] = variable;
				break;
			case 3:
				GlobalArchitectData.Instance.BoolVariables[Id] = variable;
				break;
			}
		}

		public override string GetTypeId()
		{
			return "Boolean";
		}

		public override object GetValue(string id)
		{
			int pType = PType;
			if (1 == 0)
			{
			}
			bool flag = pType switch
			{
				0 => TempVars.ContainsKey(Id) && TempVars[Id], 
				1 => SemiVars.ContainsKey(Id) && SemiVars[Id], 
				2 => ArchitectData.Instance.BoolVariables.ContainsKey(Id) && ArchitectData.Instance.BoolVariables[Id], 
				3 => GlobalArchitectData.Instance.BoolVariables.ContainsKey(Id) && GlobalArchitectData.Instance.BoolVariables[Id], 
				_ => Default, 
			};
			if (1 == 0)
			{
			}
			return flag;
		}
	}
	public class NumVarBlock : VarBlock
	{
		private static readonly Dictionary<string, float> TempVars = new Dictionary<string, float>();

		public static readonly Dictionary<string, float> SemiVars = new Dictionary<string, float>();

		public int PType;

		public float Default;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Set");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("New Value", "Number"));

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Number"));

		protected override string Name => "Variable (Number)";

		public static void Init()
		{
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				TempVars.Clear();
				if (Settings.TestMode.Value)
				{
					SemiVars.Clear();
					ArchitectData.Instance.FloatVariables.Clear();
				}
			});
		}

		protected override void Trigger(string trigger)
		{
			float variable = GetVariable<float>("New Value");
			switch (PType)
			{
			case 0:
				TempVars[Id] = variable;
				break;
			case 1:
				SemiVars[Id] = variable;
				break;
			case 2:
				ArchitectData.Instance.FloatVariables[Id] = variable;
				break;
			case 3:
				GlobalArchitectData.Instance.FloatVariables[Id] = variable;
				break;
			}
		}

		public override object GetValue(string id)
		{
			int pType = PType;
			if (1 == 0)
			{
			}
			float num = pType switch
			{
				0 => TempVars.GetValueOrDefault(Id, Default), 
				1 => SemiVars.GetValueOrDefault(Id, Default), 
				2 => ArchitectData.Instance.FloatVariables.GetValueOrDefault(Id, Default), 
				3 => GlobalArchitectData.Instance.FloatVariables.GetValueOrDefault(Id, Default), 
				_ => Default, 
			};
			if (1 == 0)
			{
			}
			return num;
		}

		public override string GetTypeId()
		{
			return "Number";
		}
	}
	public class StringVarBlock : VarBlock
	{
		private static readonly Dictionary<string, string> TempVars = new Dictionary<string, string>();

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

		public int PType;

		public string Default = string.Empty;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Set");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("New Value", "Text"));

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Value", "Text"));

		protected override string Name => "Variable (Text)";

		public static void Init()
		{
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				TempVars.Clear();
				if (Settings.TestMode.Value)
				{
					SemiVars.Clear();
					ArchitectData.Instance.StringVariables.Clear();
				}
			});
		}

		protected override void Trigger(string trigger)
		{
			string variable = GetVariable<string>("New Value");
			switch (PType)
			{
			case 0:
				TempVars[Id] = variable;
				break;
			case 1:
				SemiVars[Id] = variable;
				break;
			case 2:
				ArchitectData.Instance.StringVariables[Id] = variable;
				break;
			case 3:
				GlobalArchitectData.Instance.StringVariables[Id] = variable;
				break;
			}
		}

		public static string GetVar(string id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> tempVars = TempVars;
			Dictionary<string, string> semiVars = SemiVars;
			Dictionary<string, string> stringVariables = ArchitectData.Instance.StringVariables;
			KeyCode valueOrDefault = GlobalArchitectData.Instance.Keybinds.GetValueOrDefault(id, (KeyCode)0);
			return tempVars.GetValueOrDefault(id, semiVars.GetValueOrDefault(id, stringVariables.GetValueOrDefault(id, ((object)(KeyCode)(ref valueOrDefault)).ToString())));
		}

		public override object GetValue(string id)
		{
			int pType = PType;
			if (1 == 0)
			{
			}
			string result = pType switch
			{
				0 => TempVars.GetValueOrDefault(Id, Default), 
				1 => SemiVars.GetValueOrDefault(Id, Default), 
				2 => ArchitectData.Instance.StringVariables.GetValueOrDefault(Id, Default), 
				3 => GlobalArchitectData.Instance.StringVariables.GetValueOrDefault(Id, Default), 
				_ => Default, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public override string GetTypeId()
		{
			return "Text";
		}
	}
}
namespace Architect.Events.Blocks.Objects
{
	public class ObjectBlock : ScriptBlock
	{
		public class ObjectBlockReference : MonoBehaviour
		{
			public ObjectBlock Block;

			public readonly List<GameObject> Spawns = new List<GameObject>();

			public bool canEvent = true;

			public void OnEvent(string eName)
			{
				if (canEvent)
				{
					Block.Event(eName);
				}
			}
		}

		public string TargetId;

		public string TypeId;

		internal static readonly Color ValidColor = new Color(0.7f, 0.3f, 0.9f);

		private static readonly Color InvalidColor = new Color(0.6f, 0f, 0f);

		private GameObject _referencedObject;

		private ObjectBlockReference _reference;

		private PlaceableObject ObjectType => PlaceableObject.RegisteredObjects.GetValueOrDefault(TypeId);

		protected override IEnumerable<string> Inputs
		{
			get
			{
				PlaceableObject objectType = ObjectType;
				PlaceableObject placeableObject = objectType;
				if (placeableObject != null)
				{
					if (placeableObject is PrefabObject prefabObject)
					{
						if (!PrefabManager.Prefabs.TryGetValue(prefabObject.Name, out var value))
						{
							LevelData levelData2 = (PrefabManager.Prefabs[prefabObject.Name] = StorageManager.LoadScene("Prefab_" + prefabObject.Name));
							value = levelData2;
						}
						foreach (ScriptBlock scriptBlock in value.ScriptBlocks)
						{
							foreach (var (_, configValue2) in scriptBlock.CurrentConfig)
							{
								configValue2.Setup(scriptBlock);
							}
						}
						return (from ReceiveBlock rb in value.ScriptBlocks.Where((ScriptBlock block) => block is ReceiveBlock receiveBlock && receiveBlock.Local)
							select rb.EventName).Distinct().Append("prefab_start").Append("prefab_destroy");
					}
					return ObjectType.ReceiverGroup.Select((EventReceiverType o) => o.Id);
				}
				return Array.Empty<string>();
			}
		}

		protected override IEnumerable<string> Outputs
		{
			get
			{
				PlaceableObject objectType = ObjectType;
				PlaceableObject placeableObject = objectType;
				if (placeableObject != null)
				{
					if (placeableObject is PrefabObject prefabObject)
					{
						if (!PrefabManager.Prefabs.TryGetValue(prefabObject.Name, out var value))
						{
							LevelData levelData2 = (PrefabManager.Prefabs[prefabObject.Name] = StorageManager.LoadScene("Prefab_" + prefabObject.Name));
							value = levelData2;
						}
						foreach (ScriptBlock scriptBlock in value.ScriptBlocks)
						{
							foreach (var (_, configValue2) in scriptBlock.CurrentConfig)
							{
								configValue2.Setup(scriptBlock);
							}
						}
						return (from BroadcastBlock rb in value.ScriptBlocks.Where((ScriptBlock block) => block is BroadcastBlock broadcastBlock && broadcastBlock.Local)
							select rb.EventName).Distinct();
					}
					return ObjectType.BroadcasterGroup;
				}
				return Array.Empty<string>();
			}
		}

		protected override IEnumerable<(string, string)> OutputVars
		{
			get
			{
				PlaceableObject objectType = ObjectType;
				PlaceableObject placeableObject = objectType;
				if (placeableObject != null)
				{
					if (placeableObject is PrefabObject prefabObject)
					{
						if (!PrefabManager.Prefabs.TryGetValue(prefabObject.Name, out var value))
						{
							LevelData levelData2 = (PrefabManager.Prefabs[prefabObject.Name] = StorageManager.LoadScene("Prefab_" + prefabObject.Name));
							value = levelData2;
						}
						foreach (ScriptBlock scriptBlock in value.ScriptBlocks)
						{
							foreach (var (_, configValue2) in scriptBlock.CurrentConfig)
							{
								configValue2.Setup(scriptBlock);
							}
						}
						return (from VarBlock rb in value.ScriptBlocks.Where((ScriptBlock block) => block is VarBlock varBlock && varBlock.Local)
							select (rb.Id, rb.GetTypeId())).Distinct().Append(("object_self", "Object"));
					}
					return ObjectType.OutputGroup.Select((OutputType o) => (o.Id, o.GetTypeId()));
				}
				return Array.Empty<(string, string)>();
			}
		}

		protected override IEnumerable<(string, string)> InputVars => ObjectType?.InputGroup ?? new List<(string, string)>();

		public override Color Color => IsValid ? ValidColor : InvalidColor;

		protected override string Name => IsValid ? ((ObjectType?.GetName() ?? "Deleted") + " (" + TargetId + ")") : ((ObjectType?.GetName() ?? "Deleted") + " (Invalid)");

		public override bool IsValid
		{
			get
			{
				if (EditManager.IsEditing)
				{
					ObjectPlacement placement = PlacementManager.GetPlacement(TargetId);
					if (placement == null)
					{
						return false;
					}
					return placement.GetPlacementType().GetId() == TypeId;
				}
				return Object.op_Implicit((Object)(object)_referencedObject);
			}
		}

		protected override Dictionary<string, string> SerializeExtraData()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("object", TargetId);
			dictionary.Add("object_type", TypeId);
			return dictionary;
		}

		protected override void DeserializeExtraData(Dictionary<string, string> data)
		{
			TargetId = data["object"];
			TypeId = data["object_type"];
		}

		public override void SetupReference()
		{
			if (PlacementManager.Objects.TryGetValue(TargetId, out _referencedObject))
			{
				_reference = _referencedObject.AddComponent<ObjectBlockReference>();
				_reference.Block = this;
			}
		}

		protected override void Trigger(string trigger)
		{
			if (!Object.op_Implicit((Object)(object)_referencedObject))
			{
				return;
			}
			EventReceiverType receiver = EventManager.GetReceiverType(trigger);
			DoTrigger(_referencedObject);
			foreach (GameObject item in _reference.Spawns.Where((GameObject spawn) => Object.op_Implicit((Object)(object)spawn)))
			{
				DoTrigger(item);
			}
			void DoTrigger(GameObject obj)
			{
				if (obj.activeInHierarchy || (receiver != null && receiver.RunWhenInactive))
				{
					if (receiver != null)
					{
						receiver.Trigger(obj, this);
					}
					else
					{
						Prefab component = obj.GetComponent<Prefab>();
						if (Object.op_Implicit((Object)(object)component))
						{
							component.Receive(trigger);
						}
					}
				}
			}
		}

		public override object GetValue(string id)
		{
			if (!Object.op_Implicit((Object)(object)_referencedObject))
			{
				return null;
			}
			Prefab component = _referencedObject.GetComponent<Prefab>();
			if (Object.op_Implicit((Object)(object)component))
			{
				object var = component.GetVar(id);
				if (var != null)
				{
					return var;
				}
			}
			return EventManager.GetOutputType(id)?.GetValue(_referencedObject);
		}
	}
	public class ObjectMoverBlock : ScriptBlock
	{
		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[8] { "MoveTo", "MoveBy", "AddForce", "SetVelocity", "SetRotation", "AddRotation", "RotateAround", "PointAt" });

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[7]
		{
			ScriptBlock.Space,
			ScriptBlock.Space,
			("Target", "Object"),
			("X", "Number"),
			("Y", "Number"),
			("Z", "Number"),
			("Angle", "Number")
		});

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[6]
		{
			("Pos X", "Number"),
			("Pos Y", "Number"),
			("Pos Z", "Number"),
			("Rotation", "Number"),
			("Force X", "Number"),
			("Force Y", "Number")
		});

		public override Color Color => ObjectBlock.ValidColor;

		protected override string Name => "Move Object";

		protected override void Trigger(string trigger)
		{
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			GameObject variable = GetVariable<GameObject>("Target");
			if (!Object.op_Implicit((Object)(object)variable))
			{
				return;
			}
			float variable2 = GetVariable<float>("Angle");
			float variable3 = GetVariable<float>("X");
			float variable4 = GetVariable<float>("Y");
			float variable5 = GetVariable<float>("Z");
			IEnumerable<Rigidbody2D> enumerable = new <>z__ReadOnlySingleElementList<Rigidbody2D>(variable.GetComponentInChildren<Rigidbody2D>());
			Prefab component = variable.GetComponent<Prefab>();
			switch (trigger)
			{
			case "MoveTo":
			{
				float variable6 = GetVariable<float>("X", Extensions.GetPositionX(variable.transform));
				float variable7 = GetVariable<float>("Y", Extensions.GetPositionY(variable.transform));
				float variable8 = GetVariable<float>("Z", Extensions.GetPositionZ(variable.transform));
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(variable6, variable7, variable8);
				if (Object.op_Implicit((Object)(object)component))
				{
					component.Move(val);
				}
				else
				{
					variable.transform.position = val;
				}
				break;
			}
			case "MoveBy":
			{
				Vector3 val2 = variable.transform.position + new Vector3(variable3, variable4, variable5);
				if (Object.op_Implicit((Object)(object)component))
				{
					component.Move(val2);
				}
				else
				{
					variable.transform.position = val2;
				}
				break;
			}
			case "AddForce":
				if (Object.op_Implicit((Object)(object)component))
				{
					enumerable = component.spawns.SelectMany((GameObject o) => o.GetComponentsInChildren<Rigidbody2D>());
				}
				{
					foreach (Rigidbody2D item in enumerable)
					{
						item.linearVelocityX += variable3;
						item.linearVelocityY += variable4;
					}
					break;
				}
			case "SetVelocity":
				if (Object.op_Implicit((Object)(object)component))
				{
					enumerable = component.spawns.SelectMany((GameObject o) => o.GetComponentsInChildren<Rigidbody2D>());
				}
				{
					foreach (Rigidbody2D item2 in enumerable)
					{
						float variable9 = GetVariable<float>("X", item2.linearVelocityX);
						float variable10 = GetVariable<float>("Y", item2.linearVelocityY);
						item2.linearVelocityX = variable9;
						item2.linearVelocityY = variable10;
					}
					break;
				}
			case "SetRotation":
				if (Object.op_Implicit((Object)(object)component))
				{
					component.SetRotation(variable2);
				}
				else
				{
					Extensions.SetRotation2D(variable.transform, variable2);
				}
				break;
			case "AddRotation":
				if (Object.op_Implicit((Object)(object)component))
				{
					component.SetRotation(component.rot + variable2);
				}
				else
				{
					Extensions.SetRotation2D(variable.transform, Extensions.GetRotation2D(variable.transform) + variable2);
				}
				break;
			case "PointAt":
			{
				float num = Mathf.Atan((variable4 - Extensions.GetPositionY(variable.transform)) / (variable3 - Extensions.GetPositionX(variable.transform))) * 57.29578f + variable2;
				if (variable3 - Extensions.GetPositionX(variable.transform) < 0f)
				{
					num += 180f;
				}
				if (Object.op_Implicit((Object)(object)component))
				{
					component.SetRotation(num);
				}
				else
				{
					Extensions.SetRotation2D(variable.transform, num);
				}
				break;
			}
			}
		}

		public override object GetValue(string id)
		{
			GameObject variable = GetVariable<GameObject>("Target");
			if (!Object.op_Implicit((Object)(object)variable))
			{
				return 0;
			}
			if (!(id == "Force X"))
			{
				if (id == "Force Y")
				{
					Rigidbody2D component = variable.GetComponent<Rigidbody2D>();
					if (!Object.op_Implicit((Object)(object)component))
					{
						return 0;
					}
					return component.linearVelocityY;
				}
				if (1 == 0)
				{
				}
				float num = id switch
				{
					"Pos X" => Extensions.GetPositionX(variable.transform), 
					"Pos Y" => Extensions.GetPositionY(variable.transform), 
					"Pos Z" => Extensions.GetPositionZ(variable.transform), 
					"Rotation" => Extensions.GetRotation2D(variable.transform), 
					_ => 0f, 
				};
				if (1 == 0)
				{
				}
				return num;
			}
			Rigidbody2D component2 = variable.GetComponent<Rigidbody2D>();
			if (!Object.op_Implicit((Object)(object)component2))
			{
				return 0;
			}
			return component2.linearVelocityX;
		}
	}
	public class SpawnObjectBlock : ScriptBlock
	{
		[CompilerGenerated]
		private sealed class <DoSpawn>d__18 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlaceableObject placeable;

			public SpawnObjectBlock <>4__this;

			private ObjectPlacement <placement>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = placeable.EnsureLoaded();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<placement>5__1 = new ObjectPlacement(placeable, new Vector3(<>4__this.GetVariable<float>("X") + <>4__this.OffsetX, <>4__this.GetVariable<float>("Y") + <>4__this.OffsetY, placeable.ZPosition), <>4__this.BlockId, <>4__this.GetVariable<bool>("Flipped"), <>4__this.GetVariable<float>("Rot"), <>4__this.GetVariable<float>("Scale", 1), locked: false, 0, Array.Empty<(string, string)>(), Array.Empty<(string, string, int)>(), (from c in placeable.ConfigGroup
						select c.GetDefaultValue() into c
						where c != null
						select c).ToArray());
					<>4__this._last = <placement>5__1.SpawnObject();
					<>4__this._last.RemoveComponent<PersistentBoolItem>();
					<>4__this._last.SetActive(true);
					<>4__this.Event("OnSpawned");
					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 float OffsetX;

		public float OffsetY;

		private GameObject _last;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Spawn");

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnSpawned");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[8]
		{
			ScriptBlock.Space,
			ScriptBlock.Space,
			("Type", "Text"),
			("X", "Number"),
			("Y", "Number"),
			("Rot", "Number"),
			("Scale", "Number"),
			("Flipped", "Boolean")
		});

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Last", "Object"));

		public override Color Color => ObjectBlock.ValidColor;

		protected override string Name => "Spawn Object";

		public override void Reset()
		{
			OffsetX = 0f;
			OffsetY = 0f;
		}

		protected override void Trigger(string trigger)
		{
			string type = GetVariable<string>("Type");
			if (!Utility.IsNullOrWhiteSpace(type))
			{
				PlaceableObject placeableObject = PlaceableObject.RegisteredObjects.Values.FirstOrDefault((PlaceableObject p) => p.GetName() == type);
				if (placeableObject != null)
				{
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(DoSpawn(placeableObject));
				}
			}
		}

		public override object GetValue(string id)
		{
			return _last;
		}

		[IteratorStateMachine(typeof(<DoSpawn>d__18))]
		private IEnumerator DoSpawn(PlaceableObject placeable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoSpawn>d__18(0)
			{
				<>4__this = this,
				placeable = placeable
			};
		}
	}
	public class SpawnPrefabBlock : ScriptBlock
	{
		public string Prefab = "";

		public float OffsetX;

		public float OffsetY;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlySingleElementList<string>("Spawn");

		protected override IEnumerable<(string, string)> InputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[5]
		{
			("X", "Number"),
			("Y", "Number"),
			("Rot", "Number"),
			("Scale", "Number"),
			("Flip", "Boolean")
		});

		public override Color Color => ObjectBlock.ValidColor;

		protected override string Name => "Spawn Prefab";

		public override void Reset()
		{
			Prefab = "";
			OffsetX = 0f;
			OffsetY = 0f;
		}

		protected override void Trigger(string trigger)
		{
			//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_005a: Unknown result type (might be due to invalid IL or missing references)
			if (!Utility.IsNullOrWhiteSpace(Prefab))
			{
				GameObject val = new GameObject($"[Architect] Prefab Spawner {Guid.NewGuid()}");
				val.transform.position = new Vector3(GetVariable<float>("X") + OffsetX, GetVariable<float>("Y") + OffsetY);
				Prefab prefab = val.AddComponent<Prefab>();
				prefab.rot = GetVariable<float>("Rot");
				prefab.scale = GetVariable<float>("Scale", 1);
				prefab.flip = GetVariable<bool>("Flip");
				prefab.id = Prefab;
			}
		}
	}
}
namespace Architect.Events.Blocks.Functions
{
	public class CallFunctionBlock : ScriptBlock
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <name>P;

		protected override string Name => <name>P;

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("Call");

		public CallFunctionBlock(string name)
		{
			<name>P = name;
			base..ctor();
		}
	}
	public class FunctionDefinitionBlock : ScriptBlock
	{
		public string FunctionName = string.Empty;

		protected override string Name => "Function";

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnCall");
	}
	public static class FunctionManager
	{
		public static void Init()
		{
			Category.Data.RegisterHiddenBlock<FunctionDefinitionBlock>("New Function", Architect.Events.Blocks.Config.ConfigGroup.Functions);
		}
	}
}
namespace Architect.Events.Blocks.Events
{
	public static class EventBlocks
	{
		public static void Init()
		{
			Category.Events.RegisterBlock<StartBlock>("Start");
			Category.Events.RegisterBlock<TimerBlock>("Timer", Architect.Events.Blocks.Config.ConfigGroup.Timer);
			Category.Events.RegisterBlock<EveryFrameBlock>("Every Frame");
			Category.Events.RegisterBlock<KeyBlock>("Key Listener", Architect.Events.Blocks.Config.ConfigGroup.KeyListener);
			Category.Events.RegisterBlock<ReceiveBlock>("Receive", Architect.Events.Blocks.Config.ConfigGroup.Receive);
			Category.Events.RegisterBlock<BroadcastBlock>("Broadcast", Architect.Events.Blocks.Config.ConfigGroup.Broadcast);
			Category.Events.RegisterBlock<MultiplayerOutBlock>("Multiplayer Receive", Architect.Events.Blocks.Config.ConfigGroup.MultiplayerOut);
			Category.Events.RegisterBlock<MultiplayerInBlock>("Multiplayer Event", Architect.Events.Blocks.Config.ConfigGroup.MultiplayerIn);
			Category.World.RegisterHiddenBlock<PlayerBlock>("Player Listener");
			Category.World.RegisterBlock<StateBlock>("Player State");
			Category.World.RegisterBlock<ActionBlock>("Player Movement");
			Category.World.RegisterBlock<AttackBlock>("Player Attacks");
			Category.World.RegisterBlock<NeedolinBlock>("Needolin Control", Architect.Events.Blocks.Config.ConfigGroup.Needolin, NeedolinBlock.Init);
		}
	}
	public class EveryFrameBlock : ToggleableBlock
	{
		public class TimerEvent : MonoBehaviour
		{
			public EveryFrameBlock Block;

			private void Update()
			{
				if (Block.Enabled)
				{
					Block.Event("OnCall");
				}
			}
		}

		private TimerEvent _te;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Disable", "Enable" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnCall");

		protected override string Name => "Every Frame";

		protected override void Trigger(string trigger)
		{
			if (trigger != "Reset")
			{
				base.Trigger(trigger);
			}
			else if (Object.op_Implicit((Object)(object)_te))
			{
				((Component)_te).gameObject.SetActive(true);
			}
		}

		public override void SetupReference()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_te = new GameObject("[Architect] Every Frame Block").AddComponent<TimerEvent>();
			_te.Block = this;
		}
	}
	public class KeyBlock : ToggleableBlock
	{
		public class CustomConfig : SingleConfig
		{
		}

		public class KeyEvent : MonoBehaviour
		{
			public KeyBlock Block;

			private void Update()
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				if (Block.Keybind != null)
				{
					Block.Key = GlobalArchitectData.Instance.Keybinds.GetValueOrDefault(Block.Keybind.Id, Block.Keybind.Default);
				}
				if (!Input.GetKeyDown(Block.Key))
				{
					PlayerAction playerAction = Block.PlayerAction;
					if (playerAction == null || !((OneAxisInputControl)playerAction).WasPressed)
					{
						goto IL_008e;
					}
				}
				Block.Event("OnPress");
				goto IL_008e;
				IL_008e:
				if (!Input.GetKeyUp(Block.Key))
				{
					PlayerAction playerAction2 = Block.PlayerAction;
					if (playerAction2 == null || !((OneAxisInputControl)playerAction2).WasReleased)
					{
						return;
					}
				}
				Block.Event("OnRelease");
			}
		}

		public KeyCode Key = (KeyCode)0;

		public PlayerAction PlayerAction = null;

		public CustomKeybind Keybind = null;

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[2] { "OnPress", "OnRelease" });

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Disable", "Enable" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Held", "Boolean"));

		protected override string Name => "Key Listener";

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			KeyEvent keyEvent = new GameObject("[Architect] Key Listener Block").AddComponent<KeyEvent>();
			keyEvent.Block = this;
		}

		protected override void Trigger(string trigger)
		{
			if (!(trigger == "Prompt"))
			{
				base.Trigger(trigger);
			}
		}

		public override object GetValue(string id)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (Keybind != null)
			{
				Key = GlobalArchitectData.Instance.Keybinds.GetValueOrDefault(Keybind.Id, Keybind.Default);
			}
			int num;
			if (!Input.GetKey(Key))
			{
				PlayerAction playerAction = PlayerAction;
				num = ((playerAction != null && ((OneAxisInputControl)playerAction).IsPressed) ? 1 : 0);
			}
			else
			{
				num = 1;
			}
			return (byte)num != 0;
		}
	}
	public class MultiplayerOutBlock : ScriptBlock
	{
		public class MpEvent : MonoBehaviour
		{
			public MultiplayerOutBlock Block;

			public static readonly List<MpEvent> Events = new List<MpEvent>();

			private void OnEnable()
			{
				Events.Add(this);
			}

			private void OnDisable()
			{
				Events.Remove(this);
			}
		}

		public string EventName;

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnReceive");

		protected override string Name => "Multiplayer Receive";

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			MpEvent mpEvent = new GameObject("[Architect] Multiplayer Out Block").AddComponent<MpEvent>();
			mpEvent.Block = this;
		}
	}
	public class NeedolinBlock : ToggleableBlock
	{
		public class NeedolinBlockRef : MonoBehaviour
		{
			public NeedolinBlock Block;

			private void OnEnable()
			{
				Refs.Add(this);
			}

			private void OnDisable()
			{
				Refs.Remove(this);
			}
		}

		private static readonly List<NeedolinBlockRef> Refs = new List<NeedolinBlockRef>();

		public int DetectionType;

		private float _timeStarted;

		private bool _playing;

		protected override string Name => "Needolin Control";

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[2] { "OnStart", "OnStop" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[2]
		{
			("Playing", "Boolean"),
			("Duration", "Number")
		});

		public static void Init()
		{
			HookUtils.OnFsmAwake = (Action<PlayMakerFSM>)Delegate.Combine(HookUtils.OnFsmAwake, (Action<PlayMakerFSM>)delegate(PlayMakerFSM fsm)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				string fsmName = fsm.FsmName;
				if ((fsmName == "Silk Specials" || fsmName == "Bench Control") ? true : false)
				{
					FsmState state = fsm.GetState("Needolin Sub");
					RunFSM val = (RunFSM)((state != null) ? state.actions[(!(fsm.FsmName == "Bench Control")) ? 2 : 0] : null);
					Fsm val2 = (((int)val != 0) ? val.fsmTemplateControl.RunFsm : null);
					if (val2 != null)
					{
						val2.GetState("End Needolin").AddAction(Stop, 0, everyFrame: false);
						val2.GetState("Needolin FT Out").AddAction(StopSpecial, 0, everyFrame: false);
						val2.GetState("Needolin Mem Out").AddAction(StopSpecial, 0, everyFrame: false);
						val2.GetState("Take Control").AddAction(delegate
						{
							Start(0);
						}, 0, everyFrame: false);
						val2.GetState("Needolin FT In").AddAction(delegate
						{
							Start(1);
						}, 0, everyFrame: false);
						val2.GetState("Needolin Mem In").AddAction(delegate
						{
							Start(2);
						}, 0, everyFrame: false);
					}
				}
			});
		}

		private static void Start(int type)
		{
			Refs.RemoveAll((NeedolinBlockRef r) => !Object.op_Implicit((Object)(object)r));
			foreach (NeedolinBlockRef item in Refs.Where((NeedolinBlockRef r) => !r.Block._playing && (r.Block.DetectionType == 0 || r.Block.DetectionType == type)))
			{
				item.Block._playing = true;
				item.Block._timeStarted = Time.time;
				item.Block.Event("OnStart");
			}
		}

		private static void Stop()
		{
			Refs.RemoveAll((NeedolinBlockRef r) => !Object.op_Implicit((Object)(object)r));
			foreach (NeedolinBlockRef item in Refs.Where((NeedolinBlockRef r) => r.Block._playing))
			{
				item.Block._playing = false;
				item.Block.Event("OnStop");
			}
		}

		private static void StopSpecial()
		{
			Refs.RemoveAll((NeedolinBlockRef r) => !Object.op_Implicit((Object)(object)r));
			foreach (NeedolinBlockRef item in Refs.Where((NeedolinBlockRef r) => r.Block._playing && r.Block.DetectionType != 0))
			{
				item.Block._playing = false;
				item.Block.Event("OnStop");
			}
		}

		public override object GetValue(string id)
		{
			if (_playing)
			{
				if (id == "Playing")
				{
					return true;
				}
				return Time.time - _timeStarted;
			}
			return (id == "Playing") ? ((object)false) : ((object)0f);
		}

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("[Architect] Needolin Block").AddComponent<NeedolinBlockRef>().Block = this;
		}
	}
	public class PlayerBlock : ToggleableBlock
	{
		public class PlayerEvent : MonoBehaviour
		{
			public ScriptBlock Block;

			private void OnEnable()
			{
				PlayerHook.PlayerListenerBlocks.Add(this);
			}

			private void OnDisable()
			{
				PlayerHook.PlayerListenerBlocks.Remove(this);
			}
		}

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[16]
		{
			"FaceLeft", "FaceRight", "Jump", "WallJump", "DoubleJump", "Land", "HardLand", "Dash", "Attack", "OnHazardRespawn",
			"OnDamage", "OnDeath", "OnHeal", "OnHealFail", "NeedolinStart", "NeedolinStop"
		});

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[8]
		{
			("X", "Number"),
			("Y", "Number"),
			("Ground", "Boolean"),
			("Left", "Boolean"),
			("Right", "Boolean"),
			("Up", "Boolean"),
			("Down", "Boolean"),
			("Self", "Object")
		});

		protected override string Name => "Player Listener";

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			PlayerEvent playerEvent = new GameObject("[Architect] Player Block").AddComponent<PlayerEvent>();
			playerEvent.Block = this;
		}

		public override object GetValue(string id)
		{
			if (1 == 0)
			{
			}
			object result = id switch
			{
				"Ground" => !HeroController.instance.cState.onGround, 
				"Left" => !HeroController.instance.cState.facingRight, 
				"Right" => HeroController.instance.cState.facingRight, 
				"Up" => HeroController.instance.cState.lookingUp, 
				"Down" => HeroController.instance.cState.lookingDown, 
				"Benched" => PlayerData.instance.atBench, 
				"Sprinting" => HeroController.instance.sprintFSM.ActiveStateName.Contains("Sprint"), 
				"Floating" => HeroController.instance.umbrellaFSM.ActiveStateName == "Float Idle", 
				"Clawlining" => HeroController.instance.harpoonDashFSM.ActiveStateName == "Catch" || HeroController.instance.harpoonDashFSM.ActiveStateName == "Dash", 
				"X" => Extensions.GetPositionX(HeroController.instance.transform), 
				"Y" => Extensions.GetPositionY(HeroController.instance.transform), 
				"Self" => ((Component)HeroController.instance).gameObject, 
				_ => throw new ArgumentOutOfRangeException("id", id, null), 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class StateBlock : PlayerBlock
	{
		protected override string Name => "Player State";

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[6] { "OnFaceLeft", "OnFaceRight", "OnLand", "OnHardLand", "OnBench", "OnUnbench" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[7]
		{
			("Ground", "Boolean"),
			("Left", "Boolean"),
			("Right", "Boolean"),
			("Up", "Boolean"),
			("Down", "Boolean"),
			("Benched", "Boolean"),
			("Self", "Object")
		});
	}
	public class ActionBlock : PlayerBlock
	{
		protected override string Name => "Player Movement";

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[4] { "RefreshDash", "RefreshDoubleJump", "Disable", "Enable" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[7] { "OnJump", "OnWallJump", "OnDoubleJump", "OnInflate", "OnDownDash", "OnDash", "OnClawline" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlyArray<(string, string)>(new(string, string)[6]
		{
			("X", "Number"),
			("Y", "Number"),
			("Sprinting", "Boolean"),
			("Floating", "Boolean"),
			("Clawlining", "Boolean"),
			("Self", "Object")
		});

		protected override void Trigger(string id)
		{
			if (id == "RefreshDash")
			{
				HeroController.instance.airDashed = false;
				HeroController.instance.dashCooldownTimer = 0f;
			}
			else
			{
				HeroController.instance.doubleJumped = false;
			}
		}
	}
	public class AttackBlock : PlayerBlock
	{
		protected override string Name => "Player Attack";

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlyArray<string>(new string[5] { "OnAttack", "OnNormalAttack", "OnUpAttack", "OnDownAttack", "OnDashAttack" });

		protected override IEnumerable<(string, string)> OutputVars => new <>z__ReadOnlySingleElementList<(string, string)>(("Self", "Object"));
	}
	public class ReceiveBlock : LocalBlock
	{
		public class RcEvent : MonoBehaviour
		{
			public ReceiveBlock Block;

			public static readonly List<RcEvent> Events = new List<RcEvent>();

			private void OnEnable()
			{
				Events.Add(this);
			}

			private void OnDisable()
			{
				Events.Remove(this);
			}
		}

		public string ActualEventName = string.Empty;

		public string EventName = string.Empty;

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnReceive");

		protected override string Name => "Receive";

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			RcEvent rcEvent = new GameObject("[Architect] Receive Block").AddComponent<RcEvent>();
			rcEvent.Block = this;
		}
	}
	public class StartBlock : ScriptBlock
	{
		public class StartEvent : MonoBehaviour
		{
			public StartBlock Block;

			private bool _done;

			private void Update()
			{
				if (!_done)
				{
					_done = true;
					Block.Event("OnStart");
				}
			}
		}

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnStart");

		protected override string Name => "On Room Load";

		public override void SetupReference()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("[Architect] Start Block").AddComponent<StartEvent>().Block = this;
		}
	}
	public class TimerBlock : ToggleableBlock
	{
		public class TimerEvent : MonoBehaviour
		{
			public TimerBlock Block;

			private int _calls;

			private float _time;

			private float _cRepeatDelay;

			public float cStartDelay;

			public void Restart()
			{
				_time = 0f;
				_calls = 0;
				cStartDelay = Block.StartDelay;
			}

			private void Update()
			{
				if (!Block.Enabled)
				{
					return;
				}
				if (cStartDelay > 0f)
				{
					cStartDelay -= Time.deltaTime;
					if (cStartDelay > 0f)
					{
						return;
					}
					_time -= cStartDelay;
				}
				else
				{
					_time += Time.deltaTime;
					if (_time < _cRepeatDelay)
					{
						return;
					}
					_time -= _cRepeatDelay;
				}
				_calls++;
				_cRepeatDelay = Block.RepeatDelay + Random.value * Block.RandDelay;
				Block.Event("OnCall");
				if (Block.MaxCalls != -1 && _calls >= Block.MaxCalls)
				{
					_calls = 0;
					((Component)this).gameObject.SetActive(false);
				}
			}
		}

		public float StartDelay = 1f;

		public float RepeatDelay = 1f;

		public float RandDelay;

		public int MaxCalls = -1;

		private TimerEvent _te;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[3] { "Reset", "Disable", "Enable" });

		protected override IEnumerable<string> Outputs => new <>z__ReadOnlySingleElementList<string>("OnCall");

		protected override string Name => "Timer";

		protected override void Trigger(string trigger)
		{
			if (trigger != "Reset")
			{
				base.Trigger(trigger);
			}
			else if (Object.op_Implicit((Object)(object)_te))
			{
				((Component)_te).gameObject.SetActive(true);
				_te.Restart();
			}
		}

		public override void SetupReference()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_te = new GameObject("[Architect] Timer Block").AddComponent<TimerEvent>();
			_te.Block = this;
			_te.cStartDelay = StartDelay;
		}
	}
	public abstract class ToggleableBlock : ScriptBlock
	{
		protected bool Enabled = true;

		protected override IEnumerable<string> Inputs => new <>z__ReadOnlyArray<string>(new string[2] { "Disable", "Enable" });

		public override void Reset()
		{
			Enabled = true;
		}

		public override void Event(string name)
		{
			if (Enabled)
			{
				base.Event(name);
			}
		}

		protected override void Trigger(string trigger)
		{
			Enabled = trigger == "Enable";
		}
	}
}
namespace Architect.Events.Blocks.Config
{
	public static class ConfigGroup
	{
		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Constants = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<ConstantBlock>("Configurable", "prefab_configurable", delegate(ConstantBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<ConstantBlock> f)
			{
				b.Public = f.GetValue();
			}).WithDefaultValue(value: false).MarkPrefabOnly()),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ConstantBlock>("Name", "prefab_configurable_name", delegate(ConstantBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ConstantBlock> f)
			{
				b.ConfigName = f.GetValue();
			}).MarkPrefabOnly())
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> ConstantNum = GroupUtils.Merge(Constants, new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<ConstantNumBlock>("Number", "constant_num", delegate(ConstantNumBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<ConstantNumBlock> f)
		{
			b.Value = f.GetValue();
		})) });

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> ConstantBool = GroupUtils.Merge(Constants, new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<ConstantBoolBlock>("Bool", "constant_bool", delegate(ConstantBoolBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<ConstantBoolBlock> f)
		{
			b.Value = f.GetValue();
		})) });

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> ConstantText = GroupUtils.Merge(Constants, new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ConstantTextBlock>("Text", "constant_text", delegate(ConstantTextBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ConstantTextBlock> f)
		{
			b.Value = f.GetValue();
		})) });

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Counter = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<CounterBlock>("Target", "counter_target", delegate(CounterBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<CounterBlock> f)
		{
			b.Count = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> RandomTrigger = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<RandomEventBlock.TriggerBlock>("Weight", "random_trigger_chance", delegate(RandomEventBlock.TriggerBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<RandomEventBlock.TriggerBlock> f)
		{
			b.Chance = Mathf.Max(f.GetValue(), 0f);
		}).WithDefaultValue(1f)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Raycast = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<RaycastBlock>("Max Distance", "raycast_max_dist", delegate(RaycastBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<RaycastBlock> f)
			{
				b.MaxDistance = f.GetValue();
			}).WithDefaultValue(10f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<RaycastBlock>("Mode", "raycast_mode", delegate(RaycastBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<RaycastBlock> f)
			{
				b.Mode = f.GetValue();
			}).WithDefaultValue(0).WithOptions("Terrain", "Enemies", "Player"))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> SpawnObject = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SpawnObjectBlock>("Offset X", "spawn_object_x", delegate(SpawnObjectBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SpawnObjectBlock> f)
			{
				b.OffsetX = f.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SpawnObjectBlock>("Offset Y", "spawn_object_y", delegate(SpawnObjectBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SpawnObjectBlock> f)
			{
				b.OffsetY = f.GetValue();
			}).WithDefaultValue(0f))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Prefab = new List<Architect.Events.Blocks.Config.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<SpawnPrefabBlock>("Prefab", "prefab_name", delegate(SpawnPrefabBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<SpawnPrefabBlock> f)
			{
				b.Prefab = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SpawnPrefabBlock>("Offset X", "prefab_x", delegate(SpawnPrefabBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SpawnPrefabBlock> f)
			{
				b.OffsetX = f.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SpawnPrefabBlock>("Offset Y", "prefab_y", delegate(SpawnPrefabBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SpawnPrefabBlock> f)
			{
				b.OffsetY = f.GetValue();
			}).WithDefaultValue(0f))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Lighting = new List<Architect.Events.Blocks.Config.Types.ConfigType>(6)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SetLightingBlock>("Light R", "lighting_r", delegate(SetLightingBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SetLightingBlock> f)
			{
				b.R = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SetLightingBlock>("Light G", "lighting_g", delegate(SetLightingBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SetLightingBlock> f)
			{
				b.G = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SetLightingBlock>("Light B", "lighting_b", delegate(SetLightingBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SetLightingBlock> f)
			{
				b.B = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SetLightingBlock>("Intensity", "lighting_intense", delegate(SetLightingBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SetLightingBlock> f)
			{
				b.Intensity = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SetLightingBlock>("Saturation", "lighting_sat", delegate(SetLightingBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SetLightingBlock> f)
			{
				b.Saturation = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<SetLightingBlock>("Lock", "lighting_lock", delegate(SetLightingBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<SetLightingBlock> f)
			{
				b.Lock = f.GetValue();
			}).WithDefaultValue(value: true))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Png = new List<Architect.Events.Blocks.Config.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PngBlock>("PNG URL", "png_url", delegate(PngBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<PngBlock> value)
			{
				o.Url = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<PngBlock>("Anti Aliasing", "png_antialias", delegate(PngBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<PngBlock> value)
			{
				o.Point = !value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<PngBlock>("Pixels Per Unit", "png_ppu", delegate(PngBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<PngBlock> value)
			{
				o.Ppu = value.GetValue();
			}).WithDefaultValue(100f))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> UIControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(5)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<UIBlock>("Fade R", "ui_fade_r", delegate(UIBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<UIBlock> f)
			{
				b.R = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<UIBlock>("Fade G", "ui_fade_g", delegate(UIBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<UIBlock> f)
			{
				b.G = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<UIBlock>("Fade B", "ui_fade_b", delegate(UIBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<UIBlock> f)
			{
				b.B = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<UIBlock>("Fade A", "ui_fade_a", delegate(UIBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<UIBlock> f)
			{
				b.A = f.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<UIBlock>("Fade Time", "ui_fade_duration", delegate(UIBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<UIBlock> f)
			{
				b.Duration = f.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> EnemyControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<EnemyBlock>("Damage Type", "enemy_damage_type", delegate(EnemyBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<EnemyBlock> f)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				string stringValue = f.GetStringValue();
				if (1 == 0)
				{
				}
				AttackTypes attackType = (AttackTypes)(stringValue switch
				{
					"Water" => 5, 
					"Zap" => 9, 
					"Needle" => 0, 
					_ => Enum.Parse<AttackTypes>(stringValue), 
				});
				if (1 == 0)
				{
				}
				b.AttackType = attackType;
			}).WithDefaultValue(1).WithOptions("Generic", "Needle", "Spell", "Splatter", "Water", "Lava", "Explosion", "Coal", "Fire", "Zap", "Trap")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<EnemyBlock>("Amount", "enemy_hp_amount", delegate(EnemyBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<EnemyBlock> f)
			{
				b.Health = f.GetValue();
			}).WithDefaultValue(10))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> QuestControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<QuestBlock>("Quest ID", "quest_id", delegate(QuestBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<QuestBlock> f)
		{
			b.QuestName = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> QuestItem = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<QuestboardBlock.QuestBlock>("Quest ID", "quest_item_id", delegate(QuestboardBlock.QuestBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<QuestboardBlock.QuestBlock> f)
		{
			b.QuestName = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> EntryControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<JournalEntryBlock>("Entry ID", "journal_entry_id", delegate(JournalEntryBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<JournalEntryBlock> f)
		{
			b.EntryName = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> AchievementControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<AchievementBlock>("Achieve ID", "achievement_id", delegate(AchievementBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<AchievementBlock> f)
		{
			b.AchievementName = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> ToolControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ToolBlock>("Tool ID", "tool_id", delegate(ToolBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ToolBlock> f)
			{
				b.ToolName = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<ToolBlock>("Amount", "tool_use_amount", delegate(ToolBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<ToolBlock> f)
			{
				b.Amount = f.GetValue();
			}).WithDefaultValue(1))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> CrestControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<CrestBlock>("Crest ID", "crest_id", delegate(CrestBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<CrestBlock> f)
		{
			b.CrestName = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> ItemControl = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ItemBlock>("Item ID", "item_id", delegate(ItemBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ItemBlock> f)
		{
			b.ItemName = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Transition = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TransitionBlock>("Scene ID", "trans_scene", delegate(TransitionBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<TransitionBlock> f)
			{
				b.Scene = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TransitionBlock>("Door ID", "trans_door", delegate(TransitionBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<TransitionBlock> f)
			{
				b.Door = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Needolin = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<NeedolinBlock>("Detection", "needolin_detection", delegate(NeedolinBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<NeedolinBlock> f)
		{
			b.DetectionType = f.GetValue();
		}).WithOptions("All", "Beastling", "Elegy").WithDefaultValue(0)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> ShopItem = new List<Architect.Events.Blocks.Config.Types.ConfigType>(7)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ShopBlock.ShopItemBlock>("Item ID", "shop_item_id", delegate(ShopBlock.ShopItemBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ShopBlock.ShopItemBlock> f)
			{
				b.ItemId = f.GetValue();
			}).WithDefaultValue("Rosary_Set_Small")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ShopBlock.ShopItemBlock>("Name", "shop_item_name", delegate(ShopBlock.ShopItemBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ShopBlock.ShopItemBlock> f)
			{
				b.ItemName = f.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ShopBlock.ShopItemBlock>("Description", "shop_item_desc", delegate(ShopBlock.ShopItemBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ShopBlock.ShopItemBlock> f)
			{
				b.ItemDesc = f.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<ShopBlock.ShopItemBlock>("Cost", "shop_item_cost", delegate(ShopBlock.ShopItemBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<ShopBlock.ShopItemBlock> f)
			{
				b.Cost = f.GetValue();
			}).WithDefaultValue(80)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<ShopBlock.ShopItemBlock>("Currency", "shop_item_currency", delegate(ShopBlock.ShopItemBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<ShopBlock.ShopItemBlock> f)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				b.Currency = (CurrencyType)((f.GetValue() != 0) ? 1 : 0);
			}).WithDefaultValue(0).WithOptions("Rosaries", "Shards")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ShopBlock.ShopItemBlock>("Req. Item", "shop_item_requirement", delegate(ShopBlock.ShopItemBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<ShopBlock.ShopItemBlock> f)
			{
				b.ReqItem = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<ShopBlock.ShopItemBlock>("Req. Amount", "shop_item_requirement_cost", delegate(ShopBlock.ShopItemBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<ShopBlock.ShopItemBlock> f)
			{
				b.ReqItemAmount = f.GetValue();
			}).WithDefaultValue(1))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> CollectionItem = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<CollectionViewBlock.CollectionItemBlock>("Item ID", "collection_item_id", delegate(CollectionViewBlock.CollectionItemBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<CollectionViewBlock.CollectionItemBlock> f)
		{
			b.ItemId = f.GetValue();
		}).WithDefaultValue("Rosary_Set_Small")) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> TravelUI = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TravelBlock>("Title", "travel_ui_list_name", delegate(TravelBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<TravelBlock> f)
		{
			b.Title = f.GetValue();
		}).WithDefaultValue("Sample Text")) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> TravelUITarget = new List<Architect.Events.Blocks.Config.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TravelBlock.TravelLoc>("Name", "travel_ui_name", delegate(TravelBlock.TravelLoc b, Architect.Events.Blocks.Config.Types.StringConfigValue<TravelBlock.TravelLoc> f)
			{
				b.ListName = f.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TravelBlock.TravelLoc>("X Pos", "travel_ui_x", delegate(TravelBlock.TravelLoc b, Architect.Events.Blocks.Config.Types.FloatConfigValue<TravelBlock.TravelLoc> f)
			{
				b.XPos = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TravelBlock.TravelLoc>("Y Pos", "travel_ui_y", delegate(TravelBlock.TravelLoc b, Architect.Events.Blocks.Config.Types.FloatConfigValue<TravelBlock.TravelLoc> f)
			{
				b.YPos = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> TravelList = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<LegacyTravelBlock>("Title", "travel_list_name", delegate(LegacyTravelBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<LegacyTravelBlock> f)
		{
			b.Title = f.GetValue();
		}).WithDefaultValue("Sample Text")) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Travel = new List<Architect.Events.Blocks.Config.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TravelLoc>("Name", "travel_name", delegate(TravelLoc b, Architect.Events.Blocks.Config.Types.StringConfigValue<TravelLoc> f)
			{
				b.ListName = f.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TravelLoc>("X Pos", "travel_x", delegate(TravelLoc b, Architect.Events.Blocks.Config.Types.FloatConfigValue<TravelLoc> f)
			{
				b.XPos = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TravelLoc>("Y Pos", "travel_y", delegate(TravelLoc b, Architect.Events.Blocks.Config.Types.FloatConfigValue<TravelLoc> f)
			{
				b.YPos = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Time = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<TimeBlockType>("Mode", "time_block_mode", delegate(TimeBlockType b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<TimeBlockType> f)
		{
			b.Mode = f.GetValue();
		}).WithOptions("Local", "Global").WithDefaultValue(0)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> BoolVar = new List<Architect.Events.Blocks.Config.Types.ConfigType>(4)
		{
			ConfigurationManager.RegisterConfigType(new IdConfigType<BoolVarBlock>("Variable ID", "var_id_bool", delegate(BoolVarBlock b, IdConfigValue<BoolVarBlock> f)
			{
				b.Id = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<BoolVarBlock>("Persistence", "var_persistence_bool", delegate(BoolVarBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<BoolVarBlock> f)
			{
				b.PType = f.GetValue();
			}).WithOptions("None", "Bench", "Global", "Universal").WithDefaultValue(2)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<BoolVarBlock>("Default", "var_default_bool", delegate(BoolVarBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<BoolVarBlock> f)
			{
				b.Default = f.GetValue();
			}).WithDefaultValue(value: false)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<BoolVarBlock>("Prefab-Local", "var_local_bool", delegate(BoolVarBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<BoolVarBlock> f)
			{
				b.Local = f.GetValue();
			}).WithDefaultValue(value: true).MarkPrefabOnly())
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> NumVar = new List<Architect.Events.Blocks.Config.Types.ConfigType>(4)
		{
			ConfigurationManager.RegisterConfigType(new IdConfigType<NumVarBlock>("Variable ID", "var_id_num", delegate(NumVarBlock b, IdConfigValue<NumVarBlock> f)
			{
				b.Id = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<NumVarBlock>("Persistence", "var_persistence_num", delegate(NumVarBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<NumVarBlock> f)
			{
				b.PType = f.GetValue();
			}).WithOptions("None", "Bench", "Global", "Universal").WithDefaultValue(2)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<NumVarBlock>("Default", "var_default_num", delegate(NumVarBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<NumVarBlock> f)
			{
				b.Default = f.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<NumVarBlock>("Prefab-Local", "var_local_num", delegate(NumVarBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<NumVarBlock> f)
			{
				b.Local = f.GetValue();
			}).WithDefaultValue(value: true).MarkPrefabOnly())
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> StringVar = new List<Architect.Events.Blocks.Config.Types.ConfigType>(4)
		{
			ConfigurationManager.RegisterConfigType(new IdConfigType<StringVarBlock>("Variable ID", "var_id_str", delegate(StringVarBlock b, IdConfigValue<StringVarBlock> f)
			{
				b.Id = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<StringVarBlock>("Persistence", "var_persistence_str", delegate(StringVarBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<StringVarBlock> f)
			{
				b.PType = f.GetValue();
			}).WithOptions("None", "Bench", "Global", "Universal").WithDefaultValue(2)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<StringVarBlock>("Default", "var_default_str", delegate(StringVarBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<StringVarBlock> f)
			{
				b.Default = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<StringVarBlock>("Prefab-Local", "var_local_str", delegate(StringVarBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<StringVarBlock> f)
			{
				b.Local = f.GetValue();
			}).WithDefaultValue(value: true).MarkPrefabOnly())
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> TimeSlower = new List<Architect.Events.Blocks.Config.Types.ConfigType>(5)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TimeSlowerBlock>("Time Scale", "time_scale", delegate(TimeSlowerBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TimeSlowerBlock> value)
			{
				o.TargetSpeed = value.GetValue();
			}).WithDefaultValue(0.25f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TimeSlowerBlock>("Change Time", "time_change", delegate(TimeSlowerBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TimeSlowerBlock> value)
			{
				o.ChangeTime = value.GetValue();
			}).WithDefaultValue(0.1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TimeSlowerBlock>("Wait Time", "time_wait", delegate(TimeSlowerBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TimeSlowerBlock> value)
			{
				o.WaitTime = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TimeSlowerBlock>("Return Time", "time_return", delegate(TimeSlowerBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TimeSlowerBlock> value)
			{
				o.ReturnTime = value.GetValue();
			}).WithDefaultValue(0.75f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<TimeSlowerBlock>("Disable Pause", "time_prevent_pausing", delegate(TimeSlowerBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<TimeSlowerBlock> value)
			{
				o.NoPause = value.GetValue();
			}).WithDefaultValue(value: true))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> AnimPlayer = new List<Architect.Events.Blocks.Config.Types.ConfigType>(5)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<AnimatorBlock>("Clip Name", "anim_clip", delegate(AnimatorBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<AnimatorBlock> value)
			{
				o.ClipName = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<AnimatorBlock>("Time Override", "anim_duration", delegate(AnimatorBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<AnimatorBlock> value)
			{
				o.OverrideAnimTime = true;
				o.AnimTime = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<AnimatorBlock>("Take Control", "anim_take_ctrl", delegate(AnimatorBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<AnimatorBlock> value)
			{
				o.TakeCtrl = value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<AnimatorBlock>("Clear Force X", "anim_clear_x_vel", delegate(AnimatorBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<AnimatorBlock> value)
			{
				o.ClearXVel = value.GetValue();
			}).WithDefaultValue(value: false)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<AnimatorBlock>("Clear Force Y", "anim_clear_y_vel", delegate(AnimatorBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<AnimatorBlock> value)
			{
				o.ClearYVel = value.GetValue();
			}).WithDefaultValue(value: false))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Broadcast = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new IdConfigType<BroadcastBlock>("Event ID", "in_name", delegate(BroadcastBlock o, IdConfigValue<BroadcastBlock> value)
			{
				o.EventName = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<BroadcastBlock>("Prefab-Local", "in_local", delegate(BroadcastBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<BroadcastBlock> f)
			{
				b.Local = f.GetValue();
			}).WithDefaultValue(value: true).MarkPrefabOnly())
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Receive = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new IdConfigType<ReceiveBlock>("Event ID", "out_name", delegate(ReceiveBlock o, IdConfigValue<ReceiveBlock> value)
			{
				o.EventName = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<ReceiveBlock>("Prefab-Local", "out_local", delegate(ReceiveBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<ReceiveBlock> f)
			{
				b.Local = f.GetValue();
			}).WithDefaultValue(value: true).MarkPrefabOnly())
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> MultiplayerOut = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<MultiplayerOutBlock>("Event ID", "multi_out_name", delegate(MultiplayerOutBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<MultiplayerOutBlock> value)
		{
			o.EventName = value.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> MultiplayerIn = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<MultiplayerInBlock>("Event ID", "multi_in_name", delegate(MultiplayerInBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<MultiplayerInBlock> value)
		{
			o.EventName = value.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> RandomNumber = new List<Architect.Events.Blocks.Config.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<RandomNumBlock>("Lower Bound", "random_lower", delegate(RandomNumBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<RandomNumBlock> f)
			{
				b.LowerBound = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<RandomNumBlock>("Upper Bound", "random_upper", delegate(RandomNumBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<RandomNumBlock> f)
			{
				b.UpperBound = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<RandomNumBlock>("Whole Num", "random_whole", delegate(RandomNumBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<RandomNumBlock> f)
			{
				b.WholeNumber = f.GetValue();
			}).WithDefaultValue(value: false))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> RandomText = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<RandomTextBlock>("Source", "random_text_source", delegate(RandomTextBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<RandomTextBlock> f)
			{
				b.Pool = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<RandomTextBlock>("Delimiter", "random_text_delimiter", delegate(RandomTextBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<RandomTextBlock> f)
			{
				b.Delimiter = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> CameraShaker = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<ShakeCameraBlock>("Shake Type", "camera_shake_type", delegate(ShakeCameraBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<ShakeCameraBlock> f)
		{
			b.ShakeType = f.GetValue();
		}).WithOptions("Tiny", "Small", "Medium", "Large").WithDefaultValue(2)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> HealthHook = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<HpBlock>("Amount", "health_amount", delegate(HpBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<HpBlock> f)
		{
			b.Amount = f.GetValue();
		}).WithDefaultValue(1)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> InvulHook = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<InvulBlock>("Duration", "invul_amount", delegate(InvulBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<InvulBlock> f)
		{
			b.Duration = f.GetValue();
		}).WithDefaultValue(1f)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> SilkHook = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<SilkBlock>("Amount", "silk_amount", delegate(SilkBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<SilkBlock> f)
		{
			b.Amount = f.GetValue();
		}).WithDefaultValue(1)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> CurrencyHook = new List<Architect.Events.Blocks.Config.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<CurrencyBlock>("Amount", "currency_amount", delegate(CurrencyBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<CurrencyBlock> f)
			{
				b.Amount = f.GetValue();
			}).WithDefaultValue(1)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<CurrencyBlock>("Type", "currency_type", delegate(CurrencyBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<CurrencyBlock> f)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				b.CurrencyType = (CurrencyType)((f.GetValue() != 0) ? 1 : 0);
			}).WithOptions("Rosaries", "Shell Shards").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<CurrencyBlock>("Show Counter", "currency_counter", delegate(CurrencyBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<CurrencyBlock> f)
			{
				b.ShowCounter = f.GetValue();
			}).WithDefaultValue(value: true))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> SongDisplay = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<SongBlock>("Text", "song_text", delegate(SongBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<SongBlock> f)
			{
				b.Text = f.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<SongBlock>("Duration", "song_duration", delegate(SongBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<SongBlock> f)
			{
				b.Delay = f.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> TextDisplay = new List<Architect.Events.Blocks.Config.Types.ConfigType>(8)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TextBlock>("Text", "display_text", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<TextBlock> value)
			{
				o.Text = value.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<TextBlock>("Vertical", "display_align_v", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<TextBlock> value)
			{
				o.VerticalAlignment = value.GetValue();
			}).WithOptions("Top", "Middle", "Bottom").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<TextBlock>("Horizontal", "display_align_h", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<TextBlock> value)
			{
				o.HorizontalAlignment = value.GetValue();
			}).WithOptions("Left", "Middle", "Right").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TextBlock>("Y Offset", "display_y_offset", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TextBlock> value)
			{
				o.OffsetY = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<TextBlock>("Decorators", "display_decor", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<TextBlock> value)
			{
				o.Decorators = value.GetValue();
			}).WithDefaultValue(value: true)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TextBlock>("Text R", "display_text_r", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TextBlock> value)
			{
				o.TextColour.r = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TextBlock>("Text G", "display_text_g", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TextBlock> value)
			{
				o.TextColour.g = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TextBlock>("Text B", "display_text_b", delegate(TextBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TextBlock> value)
			{
				o.TextColour.b = value.GetValue();
			}).WithDefaultValue(1f))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> TitleDisplay = new List<Architect.Events.Blocks.Config.Types.ConfigType>(5)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TitleBlock>("Header", "title_header", delegate(TitleBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<TitleBlock> value)
			{
				o.Header = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TitleBlock>("Body", "title_body", delegate(TitleBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<TitleBlock> value)
			{
				o.Body = value.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<TitleBlock>("Footer", "title_footer", delegate(TitleBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<TitleBlock> value)
			{
				o.Footer = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<TitleBlock>("Mode", "title_type", delegate(TitleBlock o, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<TitleBlock> value)
			{
				o.TitleType = value.GetValue();
			}).WithOptions("Area", "Left", "Right", "BigBoss").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<TitleBlock>("Wait to Cancel", "title_wait_cancel", delegate(TitleBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<TitleBlock> value)
			{
				o.WaitForCancel = value.GetValue();
			}).WithDefaultValue(value: false))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> PowerupDisplay = new List<Architect.Events.Blocks.Config.Types.ConfigType>(6)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PowerupGetBlock>("Prefix", "powerup_prefix", delegate(PowerupGetBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<PowerupGetBlock> value)
			{
				o.PrefixText = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PowerupGetBlock>("Name", "powerup_name", delegate(PowerupGetBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<PowerupGetBlock> value)
			{
				o.NameText = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PowerupGetBlock>("Suffix", "powerup_suffix", delegate(PowerupGetBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<PowerupGetBlock> value)
			{
				o.SuffixText = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PowerupGetBlock>("Desc 1", "powerup_desc_top", delegate(PowerupGetBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<PowerupGetBlock> value)
			{
				o.DescTopText = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PowerupGetBlock>("Desc 2", "powerup_desc_bot", delegate(PowerupGetBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<PowerupGetBlock> value)
			{
				o.DescBotText = value.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PowerupGetBlock>("Keybind", "powerup_keybind", delegate(PowerupGetBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<PowerupGetBlock> value)
			{
				o.ButtonText = value.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> ChoiceDisplay = new List<Architect.Events.Blocks.Config.Types.ConfigType>(5)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ChoiceBlock>("Text", "choice_text", delegate(ChoiceBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<ChoiceBlock> value)
			{
				o.Text = value.GetValue();
			}).WithDefaultValue("Sample Text")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<ChoiceBlock>("Requirement", "choice_requirement", delegate(ChoiceBlock o, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<ChoiceBlock> value)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				int value5 = value.GetValue();
				switch (value5)
				{
				case 0:
					o.Cost = 0;
					break;
				case 3:
					o.UseItem = true;
					break;
				}
				o.CurrencyType = (CurrencyType)(value5 != 1);
			}).WithOptions("None", "Rosaries", "Shell Shards", "Item").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<ChoiceBlock>("Cost Amount", "choice_cost", delegate(ChoiceBlock o, Architect.Events.Blocks.Config.Types.IntConfigValue<ChoiceBlock> value)
			{
				o.Cost = value.GetValue();
			}).WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<ChoiceBlock>("Item ID", "choice_item_id", delegate(ChoiceBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<ChoiceBlock> value)
			{
				o.Item = value.GetValue();
			}).WithDefaultValue("Simple Key")),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<ChoiceBlock>("Consume Item", "choice_take_item", delegate(ChoiceBlock o, Architect.Events.Blocks.Config.Types.BoolConfigValue<ChoiceBlock> value)
			{
				o.TakeItem = value.GetValue();
			}).WithDefaultValue(value: true))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> InputDisplay = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<InputBlock>("Text", "input_display_text", delegate(InputBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<InputBlock> value)
		{
			o.Text = value.GetValue();
		}).WithDefaultValue("Sample Text")) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Pd = new List<Architect.Events.Blocks.Config.Types.ConfigType>(3)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PersistentBoolBlock>("Scene ID", "ped_bool_scene", delegate(PersistentBoolBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<PersistentBoolBlock> f)
			{
				b.Group = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PersistentBoolBlock>("Data ID", "ped_bool_type", delegate(PersistentBoolBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<PersistentBoolBlock> f)
			{
				b.Data = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<PersistentBoolBlock>("Value", "ped_bool", delegate(PersistentBoolBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<PersistentBoolBlock> f)
			{
				b.Value = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> PdBool = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PlayerDataBoolBlock>("Data ID", "pd_bool_type", delegate(PlayerDataBoolBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<PlayerDataBoolBlock> f)
			{
				b.Data = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.BoolConfigType<PlayerDataBoolBlock>("Value", "pd_bool", delegate(PlayerDataBoolBlock b, Architect.Events.Blocks.Config.Types.BoolConfigValue<PlayerDataBoolBlock> f)
			{
				b.Value = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> PdInt = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PlayerDataIntBlock>("Data ID", "pd_int_type", delegate(PlayerDataIntBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<PlayerDataIntBlock> f)
			{
				b.Data = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<PlayerDataIntBlock>("Value", "pd_int", delegate(PlayerDataIntBlock b, Architect.Events.Blocks.Config.Types.IntConfigValue<PlayerDataIntBlock> f)
			{
				b.Value = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> PdFloat = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<PlayerDataFloatBlock>("Data ID", "pd_float_type", delegate(PlayerDataFloatBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<PlayerDataFloatBlock> f)
			{
				b.Data = f.GetValue();
			})),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<PlayerDataFloatBlock>("Value", "pd_float", delegate(PlayerDataFloatBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<PlayerDataFloatBlock> f)
			{
				b.Value = f.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Delay = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<DelayBlock>("Delay", "delay_num", delegate(DelayBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<DelayBlock> f)
		{
			b.Delay = f.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Loop = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<LoopBlock>("Delay", "loop_delay_num", delegate(LoopBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<LoopBlock> f)
		{
			b.Delay = f.GetValue();
		}).WithDefaultValue(0f)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Compare = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<CompareBlock>("Mode", "compare_mode", delegate(CompareBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<CompareBlock> f)
		{
			b.Mode = f.GetValue();
		}).WithOptions("=", ">", "<", ">=", "<=").WithDefaultValue(0)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> StringCompare = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<StringCompareBlock>("Mode", "string_compare_mode", delegate(StringCompareBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<StringCompareBlock> f)
		{
			b.Mode = f.GetValue();
		}).WithOptions("Equals", "Contains", "Starts", "Ends", "Longer").WithDefaultValue(0)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Maths = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<MathsBlock>("Mode", "maths_mode", delegate(MathsBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<MathsBlock> f)
		{
			b.Mode = f.GetValue();
		}).WithOptions("+", "–", "*", "/", "//", "%", "^", "Nth Root", "Min", "Max").WithDefaultValue(0)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Trig = new List<Architect.Events.Blocks.Config.Types.ConfigType>(2)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<TrigBlock>("Function", "trig_func", delegate(TrigBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<TrigBlock> f)
			{
				b.Mode = f.GetValue();
			}).WithOptions("Sin", "Cos", "Tan", "Arcsin", "Arccos", "Arctan").WithDefaultValue(0)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.ChoiceConfigType<TrigBlock>("Mode", "trig_mode", delegate(TrigBlock b, Architect.Events.Blocks.Config.Types.ChoiceConfigValue<TrigBlock> f)
			{
				b.IsDegrees = f.GetValue() == 0;
			}).WithOptions("Degrees", "Radians").WithDefaultValue(0))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Normalise = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<NormaliseBlock>("Angle", "normalise_angle", delegate(NormaliseBlock b, Architect.Events.Blocks.Config.Types.FloatConfigValue<NormaliseBlock> f)
		{
			b.Angle = f.GetValue();
		}).WithDefaultValue(0f)) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> KeyListener = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<KeyBlock>("Key", "key_listener_key", delegate(KeyBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<KeyBlock> value)
		{
			//IL_0035: 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)
			string value2 = value.GetValue();
			KeyCode result;
			PlayerAction value4;
			if (CustomKeybind.Keybinds.TryGetValue(value2, out var value3))
			{
				o.Keybind = value3;
			}
			else if (Enum.TryParse<KeyCode>(value2, ignoreCase: true, out result))
			{
				o.Key = result;
			}
			else if (((PlayerActionSet)ManagerSingleton<InputHandler>.Instance.inputActions).actionsByName.TryGetValue(value2, out value4))
			{
				o.PlayerAction = value4;
			}
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Timer = new List<Architect.Events.Blocks.Config.Types.ConfigType>(4)
		{
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TimerBlock>("Start Delay", "timer_start_delay", delegate(TimerBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TimerBlock> value)
			{
				o.StartDelay = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TimerBlock>("Repeat Delay", "timer_repeat_delay", delegate(TimerBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TimerBlock> value)
			{
				o.RepeatDelay = value.GetValue();
			}).WithDefaultValue(1f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.FloatConfigType<TimerBlock>("Random Delay", "timer_rand_delay", delegate(TimerBlock o, Architect.Events.Blocks.Config.Types.FloatConfigValue<TimerBlock> value)
			{
				o.RandDelay = value.GetValue();
			}).WithDefaultValue(0f)),
			ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.IntConfigType<TimerBlock>("Max Calls", "timer_limit", delegate(TimerBlock o, Architect.Events.Blocks.Config.Types.IntConfigValue<TimerBlock> value)
			{
				o.MaxCalls = value.GetValue();
			}))
		};

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> CustomNeedle = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new Architect.Events.Blocks.Config.Types.StringConfigType<CustomNeedleBlock>("Needle ID", "custom_needle_id", delegate(CustomNeedleBlock o, Architect.Events.Blocks.Config.Types.StringConfigValue<CustomNeedleBlock> value)
		{
			o.Value = value.GetValue();
		})) };

		public static readonly List<Architect.Events.Blocks.Config.Types.ConfigType> Functions = new List<Architect.Events.Blocks.Config.Types.ConfigType>(1) { ConfigurationManager.RegisterConfigType(new RandStringConfigType<FunctionDefinitionBlock>("Name", "function_name", delegate(FunctionDefinitionBlock b, Architect.Events.Blocks.Config.Types.StringConfigValue<FunctionDefinitionBlock> f)
		{
			b.FunctionName = f.GetValue();
		})) };
	}
	public static class ConfigurationManager
	{
		public static readonly Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigType> ConfigTypes = new Dictionary<string, Architect.Events.Blocks.Config.Types.ConfigType>();

		public static Architect.Events.Blocks.Config.Types.ConfigType RegisterConfigType(Architect.Events.Blocks.Config.Types.ConfigType type)
		{
			ConfigTypes[type.Id] = type;
			return type;
		}

		public static Architect.Events.Blocks.Config.Types.ConfigValue DeserializeConfigValue(string configType, string serializedValue)
		{
			return ConfigTypes[configType].Deserialize(serializedValue);
		}
	}
}
namespace Architect.Events.Blocks.Config.Types
{
	public class BoolConfigType<T> : ConfigType<T, BoolConfigValue<T>> where T : ScriptBlock
	{
		private bool? _defaultValue;

		public BoolConfigType(string name, string id, Action<T, BoolConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public BoolConfigType<T> WithDefaultValue(bool value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new BoolConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new BoolConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new BoolConfigValue<T>(this, Convert.ToBoolean(data, CultureInfo.InvariantCulture));
		}
	}
	public class BoolConfigValue<T> : ConfigValue<BoolConfigType<T>> where T : ScriptBlock
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private bool <value>P;

		public BoolConfigValue(BoolConfigType<T> type, bool value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public bool GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class BoolConfigElement : ConfigElement
	{
		private readonly Button _input;

		private bool _active = true;

		public BoolConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			BoolConfigElement boolConfigElement = this;
			UIUtils.Label txt;
			(_input, txt) = UIUtils.MakeTextButton("Config Input", "Default", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(120f, 25f));
			if (currentVal != null)
			{
				((Text)txt.textComponent).text = currentVal;
				_active = Convert.ToBoolean(currentVal, CultureInfo.InvariantCulture);
			}
			((UnityEvent)_input.onClick).AddListener((UnityAction)delegate
			{
				boolConfigElement._active = !boolConfigElement._active;
				((Text)txt.textComponent).text = boolConfigElement._active.ToString(CultureInfo.InvariantCulture);
				((Selectable)apply).interactable = true;
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _active.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class ChoiceConfigType<T> : ConfigType<T, ChoiceConfigValue<T>> where T : ScriptBlock
	{
		private int? _defaultValue;

		private string[] _options = Array.Empty<string>();

		public ChoiceConfigType(string name, string id, Action<T, ChoiceConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public ChoiceConfigType<T> WithOptions(params string[] options)
		{
			_options = options;
			return this;
		}

		public ChoiceConfigType<T> WithDefaultValue(int value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new ChoiceConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new ChoiceConfigElement(parent, apply, pos, currentVal, _options);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new ChoiceConfigValue<T>(this, Convert.ToInt32(data, CultureInfo.InvariantCulture));
		}

		public string GetOption(int index)
		{
			return _options[(index < _options.Length) ? index : 0];
		}
	}
	public class ChoiceConfigValue<T> : ConfigValue<ChoiceConfigType<T>> where T : ScriptBlock
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private int <value>P;

		private readonly ChoiceConfigType<T> _type;

		public ChoiceConfigValue(ChoiceConfigType<T> type, int value)
		{
			<value>P = value;
			_type = type;
			base..ctor(type);
		}

		public int GetValue()
		{
			return <value>P;
		}

		public string GetStringValue()
		{
			return _type.GetOption(<value>P);
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class ChoiceConfigElement : ConfigElement
	{
		public class ChoiceButton : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			public ChoiceConfigElement Cce;

			public void OnPointerClick(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected I4, but got Unknown
				InputButton button = eventData.button;
				InputButton val = button;
				switch ((int)val)
				{
				default:
					return;
				case 0:
					Cce._active++;
					break;
				case 1:
					if (Cce._active != -1)
					{
						Cce._active--;
					}
					break;
				case 2:
					return;
				}
				if (Cce._active < 0)
				{
					Cce._active += Cce._options.Length;
				}
				Cce._active %= Cce._options.Length;
				((Text)Cce._txt.textComponent).text = Cce._options[Cce._active];
				((Selectable)Cce._apply).interactable = true;
			}
		}

		private readonly Button _input;

		private readonly string[] _options;

		private readonly Button _apply;

		private readonly UIUtils.Label _txt;

		private int _active = -1;

		public ChoiceConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal, string[] options)
		{
			//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_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)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			(Button, UIUtils.Label) tuple = UIUtils.MakeTextButton("Config Input", "Default", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(120f, 25f));
			_input = tuple.Item1;
			_txt = tuple.Item2;
			_options = options;
			_apply = apply;
			ChoiceButton choiceButton = ((Component)_input).gameObject.AddComponent<ChoiceButton>();
			choiceButton.Cce = this;
			if (currentVal != null)
			{
				_active = Convert.ToInt32(currentVal, CultureInfo.InvariantCulture);
				((Text)_txt.textComponent).text = options[_active];
			}
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _active.ToString(CultureInfo.InvariantCulture);
		}
	}
	public abstract class ConfigType
	{
		public readonly string Name;

		public readonly string Id;

		public bool PrefabOnly;

		protected ConfigType(string name, string id)
		{
			Name = name;
			Id = id;
			base..ctor();
		}

		public abstract ConfigValue Deserialize(string data);

		[CanBeNull]
		public abstract ConfigValue GetDefaultValue();

		public ConfigType MarkPrefabOnly()
		{
			PrefabOnly = true;
			return this;
		}

		public abstract ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal);

		internal abstract void RunAction(ScriptBlock block, ConfigValue value);
	}
	public abstract class ConfigType<TType, TValue> : ConfigType where TType : ScriptBlock where TValue : ConfigValue
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Action<TType, TValue> <action>P;

		protected ConfigType(string name, string id, Action<TType, TValue> action)
		{
			<action>P = action;
			base..ctor(name, id);
		}

		internal override void RunAction(ScriptBlock obj, ConfigValue value)
		{
			<action>P(obj as TType, value as TValue);
		}
	}
	public abstract class ConfigValue
	{
		public virtual bool IsLocal => false;

		public abstract string SerializeValue();

		public abstract string GetTypeId();

		public abstract string GetName();

		public abstract void Setup(ScriptBlock block);
	}
	public abstract class ConfigValue<TType> : ConfigValue where TType : ConfigType
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private TType <type>P;

		protected ConfigValue(TType type)
		{
			<type>P = type;
			base..ctor();
		}

		public override string GetTypeId()
		{
			return <type>P.Id;
		}

		public override string GetName()
		{
			return <type>P.Name;
		}

		public override void Setup(ScriptBlock block)
		{
			<type>P.RunAction(block, this);
		}
	}
	public abstract class ConfigElement
	{
		public abstract RectTransform GetElement();

		public abstract string GetValue();
	}
	public class FloatConfigType<T> : ConfigType<T, FloatConfigValue<T>> where T : ScriptBlock
	{
		private float? _defaultValue;

		public FloatConfigType(string name, string id, Action<T, FloatConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public FloatConfigType<T> WithDefaultValue(float value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new FloatConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new FloatConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new FloatConfigValue<T>(this, Convert.ToSingle(data, CultureInfo.InvariantCulture));
		}
	}
	public class FloatConfigValue<T> : ConfigValue<FloatConfigType<T>> where T : ScriptBlock
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private float <value>P;

		public FloatConfigValue(FloatConfigType<T> type, float value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public float GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class FloatConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public FloatConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 120f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			_input.characterValidation = (CharacterValidation)2;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class IdConfigType<T> : ConfigType<T, IdConfigValue<T>> where T : ScriptBlock
	{
		[CanBeNull]
		private string _defaultValue;

		public IdConfigType(string name, string id, Action<T, IdConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public IdConfigType<T> WithDefaultValue(string value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return (_defaultValue == null) ? null : new IdConfigValue<T>(this, _defaultValue);
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new IdConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new IdConfigValue<T>(this, data);
		}
	}
	public class IdConfigValue<T> : ConfigValue<IdConfigType<T>> where T : ScriptBlock
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <value>P;

		public override bool IsLocal => true;

		public IdConfigValue(IdConfigType<T> type, string value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public string GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P;
		}
	}
	public class IdConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public IdConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 180f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class IntConfigType<T> : ConfigType<T, IntConfigValue<T>> where T : ScriptBlock
	{
		private int? _defaultValue;

		public IntConfigType(string name, string id, Action<T, IntConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public IntConfigType<T> WithDefaultValue(int value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new IntConfigValue<T>(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new IntConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new IntConfigValue<T>(this, Convert.ToInt32(data, CultureInfo.InvariantCulture));
		}
	}
	public class IntConfigValue<T> : ConfigValue<IntConfigType<T>> where T : ScriptBlock
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private int <value>P;

		public IntConfigValue(IntConfigType<T> type, int value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public int GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class IntConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public IntConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 120f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			_input.characterValidation = (CharacterValidation)1;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class StringConfigType<T> : ConfigType<T, StringConfigValue<T>> where T : ScriptBlock
	{
		[CanBeNull]
		private string _defaultValue;

		public StringConfigType(string name, string id, Action<T, StringConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public StringConfigType<T> WithDefaultValue(string value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return (_defaultValue == null) ? null : new StringConfigValue<T>(this, _defaultValue);
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new StringConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new StringConfigValue<T>(this, data);
		}
	}
	public class RandStringConfigType<T> : StringConfigType<T> where T : ScriptBlock
	{
		public RandStringConfigType(string name, string id, Action<T, StringConfigValue<T>> action)
			: base(name, id, action)
		{
		}

		public override ConfigValue GetDefaultValue()
		{
			return new StringConfigValue<T>(this, Guid.NewGuid().ToString().Substring(0, 8));
		}
	}
	public class StringConfigValue<T> : ConfigValue<StringConfigType<T>> where T : ScriptBlock
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <value>P;

		public StringConfigValue(StringConfigType<T> type, string value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public string GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P;
		}
	}
	public class StringConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public StringConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 180f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
}
namespace Architect.Editor
{
	public static class ActionManager
	{
		private static readonly List<IEdit> Before = new List<IEdit>();

		private static readonly List<IEdit> After = new List<IEdit>();

		private static string _lastScene;

		public static void Init()
		{
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				if (!(GameManager.instance.sceneName == "Temp") && !(_lastScene == "Temp") && _lastScene != GameManager.instance.sceneName)
				{
					_lastScene = GameManager.instance.sceneName;
					Before.Clear();
					After.Clear();
				}
			});
		}

		public static void UndoLast()
		{
			if (Before.Count != 0)
			{
				List<IEdit> before = Before;
				IEdit edit = before[before.Count - 1].Undo();
				if (edit != null)
				{
					edit.Execute();
					MultiplayerShare(edit);
					After.Add(edit);
					Before.RemoveAt(Before.Count - 1);
				}
				else
				{
					Before.Clear();
				}
			}
		}

		public static void RedoLast()
		{
			if (After.Count != 0)
			{
				List<IEdit> after = After;
				IEdit edit = after[after.Count - 1].Undo();
				if (edit != null)
				{
					edit.Execute();
					MultiplayerShare(edit);
					Before.Add(edit);
				}
				else
				{
					After.Clear();
				}
				After.RemoveAt(After.Count - 1);
			}
		}

		public static void PerformAction(IEdit edit)
		{
			_lastScene = GameManager.instance.sceneName;
			edit.Execute();
			MultiplayerShare(edit);
			After.Clear();
			Before.Add(edit);
		}

		public static void ReceiveAction(IEdit edit)
		{
			edit.Execute();
		}

		public static void MultiplayerShare(IEdit edit)
		{
			if (CoopManager.Instance.IsActive())
			{
				edit.MultiplayerShare();
			}
		}
	}
	public interface IEdit
	{
		void Execute();

		IEdit Undo();

		void MultiplayerShare();
	}
	public interface IScheduledEdit
	{
		void ExecuteScheduled(LevelData levelData);
	}
	public class PlaceObjects : IEdit, IScheduledEdit
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private List<ObjectPlacement> <placements>P;

		public PlaceObjects(List<ObjectPlacement> placements)
		{
			<placements>P = placements;
			base..ctor();
		}

		public void Execute()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			foreach (ObjectPlacement item in <placements>P)
			{
				PlacementManager.GetLevelData().Placements.Add(item);
				if (EditManager.IsEditing)
				{
					item.PlaceGhost();
				}
			}
		}

		public void Execute(string scene)
		{
			StorageManager.ScheduleEdit(scene, this);
		}

		public IEdit Undo()
		{
			return new EraseObject(<placements>P);
		}

		public void MultiplayerShare()
		{
			CoopManager.Instance.PlaceObjects(GameManager.instance.sceneName, <placements>P);
		}

		public void ExecuteScheduled(LevelData levelData)
		{
			levelData.Placements.AddRange(<placements>P);
		}
	}
	public class ToggleLock : IEdit
	{
		public class ScheduledToggleLock : IScheduledEdit
		{
			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private string <id>P;

			public ScheduledToggleLock(string id)
			{
				<id>P = id;
				base..ctor();
			}

			public void ExecuteScheduled(LevelData levelData)
			{
				levelData.Placements.FirstOrDefault((ObjectPlacement o) => o.GetId() == <id>P)?.ToggleLocked();
			}
		}

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private ObjectPlacement <placement>P;

		public ToggleLock(ObjectPlacement placement)
		{
			<placement>P = placement;
			base..ctor();
		}

		public void Execute()
		{
			<placement>P.ToggleLocked();
		}

		public static void Execute(string scene, string id)
		{
			StorageManager.ScheduleEdit(scene, new ScheduledToggleLock(id));
		}

		public IEdit Undo()
		{
			return new ToggleLock(<placement>P);
		}

		public void MultiplayerShare()
		{
			CoopManager.Instance.ToggleLock(GameManager.instance.sceneName, <placement>P.GetId());
		}
	}
	public class EraseObject : IEdit
	{
		public class ScheduledErase : IScheduledEdit
		{
			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private List<string> <ids>P;

			public ScheduledErase(List<string> ids)
			{
				<ids>P = ids;
				base..ctor();
			}

			public void ExecuteScheduled(LevelData levelData)
			{
				levelData.Placements.RemoveAll((ObjectPlacement o) => <ids>P.Remove(o.GetId()));
			}
		}

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private List<ObjectPlacement> <placements>P;

		public EraseObject(List<ObjectPlacement> placements)
		{
			<placements>P = placements;
			base..ctor();
		}

		public void Execute()
		{
			foreach (ObjectPlacement item in <placements>P)
			{
				PlacementManager.GetPlacement(item.GetId())?.Destroy();
			}
		}

		public static void Execute(string scene, List<string> removals)
		{
			StorageManager.ScheduleEdit(scene, new ScheduledErase(removals));
		}

		public IEdit Undo()
		{
			return new PlaceObjects(<placements>P);
		}

		public void MultiplayerShare()
		{
			CoopManager.Instance.EraseObjects(GameManager.instance.sceneName, <placements>P.Select((ObjectPlacement o) => o.GetId()).ToList());
		}
	}
	public class ToggleTile : IEdit, IScheduledEdit
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private List<(int, int)> <tiles>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private bool <empty>P;

		public ToggleTile(List<(int, int)> tiles, bool empty)
		{
			<tiles>P = tiles;
			<empty>P = empty;
			base..ctor();
		}

		public void Execute()
		{
			tk2dTileMap tilemap = PlacementManager.GetTilemap();
			if (!Object.op_Implicit((Object)(object)tilemap))
			{
				return;
			}
			foreach (var (num, num2) in <tiles>P)
			{
				try
				{
					if (<empty>P)
					{
						tilemap.ClearTile(num, num2, 0);
					}
					else
					{
						tilemap.SetTile(num, num2, 0, 0);
					}
				}
				catch (Exception)
				{
				}
				PlacementManager.GetLevelData().ToggleTile((num, num2));
			}
			tilemap.Build();
		}

		public void Execute(string scene)
		{
			StorageManager.ScheduleEdit(scene, this);
		}

		public IEdit Undo()
		{
			return new ToggleTile(<tiles>P, !<empty>P);
		}

		public void MultiplayerShare()
		{
			CoopManager.Instance.ToggleTiles(GameManager.instance.sceneName, <tiles>P, <empty>P);
		}

		public void ExecuteScheduled(LevelData levelData)
		{
			foreach (var item in <tiles>P)
			{
				levelData.ToggleTile(item);
			}
		}
	}
	public class MoveObjects : IEdit
	{
		public class ScheduledMove : IScheduledEdit
		{
			[CompilerGenerated]
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			private List<(string, Vector3)> <data>P;

			public ScheduledMove(List<(string, Vector3)> data)
			{
				<data>P = data;
				base..ctor();
			}

			public void ExecuteScheduled(LevelData levelData)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				foreach (var item in <data>P)
				{
					var (id, newWorldPos) = item;
					levelData.Placements.FirstOrDefault((ObjectPlacement o) => o.GetId() == id)?.Move(newWorldPos);
				}
			}
		}

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private List<(ObjectPlacement, Vector3, Vector3)> <data>P;

		public MoveObjects(List<(ObjectPlacement, Vector3, Vector3)> data)
		{
			<data>P = data;
			base..ctor();
		}

		public void Execute()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			foreach (var (objectPlacement, newWorldPos, _) in <data>P)
			{
				PlacementManager.GetPlacement(objectPlacement.GetId())?.Move(newWorldPos);
			}
		}

		public static void Execute(string scene, List<(string, Vector3)> movements)
		{
			StorageManager.ScheduleEdit(scene, new ScheduledMove(movements));
		}

		public IEdit Undo()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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)
			List<(ObjectPlacement, Vector3, Vector3)> list = new List<(ObjectPlacement, Vector3, Vector3)>();
			foreach (var (item, item2, item3) in <data>P)
			{
				list.Add((item, item3, item2));
			}
			return new MoveObjects(list);
		}

		public void MultiplayerShare()
		{
			CoopManager.Instance.MoveObjects(GameManager.instance.sceneName, <data>P.Select(((ObjectPlacement, Vector3, Vector3) o) => (o.Item1.GetId(), o.Item2)).ToList());
		}
	}
	public class ResetRoom : IEdit
	{
		public void Execute()
		{
			LevelData levelData = PlacementManager.GetLevelData();
			while (levelData.Placements.Count > 0)
			{
				levelData.Placements[0].Destroy();
			}
			ScriptBlock[] array = levelData.ScriptBlocks.ToArray();
			foreach (ScriptBlock scriptBlock in array)
			{
				scriptBlock.Delete();
			}
			levelData.ScriptBlocks.Clear();
			tk2dTileMap tilemap = PlacementManager.GetTilemap();
			if (!Object.op_Implicit((Object)(object)tilemap))
			{
				return;
			}
			foreach (var (num, num2) in levelData.TilemapChanges)
			{
				try
				{
					if (tilemap.GetTile(num, num2, 0) == -1)
					{
						tilemap.SetTile(num, num2, 0, 0);
					}
					else
					{
						tilemap.ClearTile(num, num2, 0);
					}
				}
				catch (Exception)
				{
				}
			}
			tilemap.Build();
			levelData.TilemapChanges.Clear();
		}

		public static void Execute(string scene)
		{
			StorageManager.SaveScene(scene, new LevelData(new List<ObjectPlacement>(), new List<(int, int)>(), new List<ScriptBlock>(), new List<Comment>()));
		}

		public IEdit Undo()
		{
			return null;
		}

		public void MultiplayerShare()
		{
			CoopManager.Instance.ResetRoom(GameManager.instance.sceneName);
		}
	}
	[JsonConverter(typeof(CommentConverter))]
	public class Comment
	{
		public class CommentConverter : JsonConverter<Comment>
		{
			private class ColorData
			{
				public float R = color.r;

				public float G = color.g;

				public float B = color.b;

				public float A = color.a;

				public ColorData(Color color)
				{
				}//IL_0001: 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_0019: 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)

			}

			public override void WriteJson(JsonWriter writer, Comment value, JsonSerializer serializer)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				writer.WriteStartObject();
				writer.WritePropertyName("title");
				writer.WriteValue(value.Title);
				writer.WritePropertyName("color");
				serializer.Serialize(writer, (object)new ColorData(value.Color));
				writer.WritePropertyName("position");
				serializer.Serialize(writer, (object)value.Position);
				writer.WritePropertyName("size");
				serializer.Serialize(writer, (object)value.Size);
				writer.WritePropertyName("isLocal");
				writer.WriteValue(value.IsLocal);
				writer.WriteEndObject();
			}

			public override Comment ReadJson(JsonReader reader, Type objectType, Comment existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Invalid comparison between Unknown and I4
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: 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)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				if ((int)reader.TokenType != 1)
				{
					return null;
				}
				string title = "Comment";
				Color color = default(Color);
				((Color)(ref color))..ctor(0f, 0f, 0f, 0.25f);
				Vector2 position = Vector2.zero;
				Vector2 size = Vector2.zero;
				bool isLocal = true;
				reader.Read();
				while ((int)reader.TokenType == 4)
				{
					string text = reader.Value as string;
					reader.Read();
					switch (text)
					{
					case "title":
						title = (reader.Value as string) ?? "Comment";
						break;
					case "color":
					{
						ColorData colorData = serializer.Deserialize<ColorData>(reader);
						if (colorData != null)
						{
							((Color)(ref color))..ctor(colorData.R, colorData.G, colorData.B, colorData.A);
						}
						break;
					}
					case "position":
						position = serializer.Deserialize<Vector2>(reader);
						break;
					case "size":
						size = serializer.Deserialize<Vector2>(reader);
						break;
					case "isLocal":
					{
						object value = reader.Value;
						isLocal = value is bool && (bool)value;
						break;
					}
					}
					reader.Read();
				}
				return new Comment(title, color, position, size, isLocal);
			}
		}

		public string Title { get; set; }

		public Color Color { get; set; }

		public Vector2 Position { get; set; }

		public Vector2 Size { get; set; }

		public bool IsLocal { get; set; }

		public Comment()
		{
		}

		public Comment(string title, Color color, Vector2 position, Vector2 size, bool isLocal)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Title = title;
			Color = color;
			Position = position;
			Size = size;
			IsLocal = isLocal;
		}
	}
	internal class CommentData : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IDragHandler, IBeginDragHandler
	{
		public Comment Comment;

		private float _time;

		public void Select()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)((Component)this).transform;
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			val.GetWorldCorners(array);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(float.MaxValue, float.MaxValue);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(float.MinValue, float.MinValue);
			for (int i = 0; i < 4; i++)
			{
				Vector2 val4 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[i]);
				val2 = Vector2.Min(val2, val4);
				val3 = Vector2.Max(val3, val4);
			}
			Rect selectionRect = default(Rect);
			((Rect)(ref selectionRect))..ctor(val2, val3 - val2);
			ScriptEditorUI.BackgroundDrag.DoSelection(selectionRect);
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 0)
			{
				ScriptManager.ClearSelection();
			}
			if (Time.realtimeSinceStartup - _time < 0.5f)
			{
				Select();
			}
			_time = Time.realtimeSinceStartup;
		}

		public void OnDrag(PointerEventData eventData)
		{
			ScriptEditorUI.Drag.OnDrag(eventData);
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			ScriptEditorUI.Drag.OnBeginDrag(eventData);
		}
	}
	public static class CursorManager
	{
		private static GameObject _cursorObject;

		private static SpriteRenderer _renderer;

		public static bool NeedsRefresh = true;

		public static bool ObjectChanged = true;

		public static Vector3 Offset;

		private static bool _needsFullRefresh = true;

		private static float _canFullRefreshTime;

		private static float _prevScale = 1f;

		public static void Init()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			_cursorObject = new GameObject("[Architect] Cursor");
			_renderer = _cursorObject.AddComponent<SpriteRenderer>();
			_cursorObject.SetActive(false);
			_renderer.color = new Color(1f, 0.2f, 0.2f, 0.5f);
			Object.DontDestroyOnLoad((Object)(object)_cursorObject);
		}

		public static void Update()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!EditManager.IsEditing || !Object.op_Implicit((Object)(object)HeroController.instance) || GameManager.instance.isPaused || !(EditManager.CurrentObject is PlaceableObject obj))
			{
				_cursorObject.SetActive(false);
				return;
			}
			if (!_cursorObject.activeSelf || NeedsRefresh || (_canFullRefreshTime < Time.time && _needsFullRefresh))
			{
				_cursorObject.SetActive(true);
				NeedsRefresh = false;
				_needsFullRefresh = false;
				Refresh(obj);
			}
			_cursorObject.transform.position = EditManager.GetWorldPos(Input.mousePosition, lockAxisApplies: true) + Offset;
		}

		public static void Refresh(PlaceableObject obj)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			float num = EditManager.CurrentRotation + obj.Rotation;
			float z = Offset.z;
			Offset = PreviewUtils.FixPreview(_renderer, obj, EditManager.CurrentlyFlipped, num, EditManager.CurrentScale);
			VideoPlayer component = _cursorObject.GetComponent<VideoPlayer>();
			if (ObjectChanged)
			{
				if (Object.op_Implicit((Object)(object)component))
				{
					component.url = "";
				}
				_cursorObject.transform.localScale = obj.LossyScale * EditManager.CurrentScale;
				_renderer.sprite = obj.Sprite;
			}
			else
			{
				_cursorObject.transform.localScale = _cursorObject.transform.localScale / _prevScale * EditManager.CurrentScale;
			}
			_prevScale = EditManager.CurrentScale;
			Extensions.SetRotation2D(_cursorObject.transform, num + obj.ChildRotation + (float)obj.Tk2dRotation);
			if (_canFullRefreshTime > Time.time && !ObjectChanged)
			{
				Offset.z = z;
				_needsFullRefresh = true;
				return;
			}
			_cursorObject.transform.localScale = obj.LossyScale * EditManager.CurrentScale;
			ObjectChanged = false;
			_canFullRefreshTime = Time.time + 2f;
			Offset.z += obj.ZPosition + 0.001f;
			((Renderer)_renderer).sortingOrder = 0;
			if (Object.op_Implicit((Object)(object)component))
			{
				component.url = "";
			}
			foreach (Architect.Config.Types.ConfigValue item in EditManager.Config.Values.OrderBy((Architect.Config.Types.ConfigValue configVal) => configVal.GetPriority()))
			{
				item.SetupPreview(_cursorObject, Architect.Config.ConfigurationManager.PreviewContext.Cursor);
			}
		}
	}
	public static class EditManager
	{
		public static bool IsEditing;

		public static bool ReloadRequired;

		public static bool IgnoreControlRelinquished;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private static int <Layer>k__BackingField;

		public static bool ShowLayersByDefault = true;

		public static readonly List<int> FlippedLayers = new List<int>();

		public static readonly List<Func<bool>> ToggleChecks = new List<Func<bool>>();

		private static float _lastEditToggle;

		private static int _hotbarIndex;

		private static readonly SelectableObject[] HotbarCurrentObject = new SelectableObject[9]
		{
			CursorObject.Instance,
			BlankObject.Instance,
			BlankObject.Instance,
			BlankObject.Instance,
			BlankObject.Instance,
			BlankObject.Instance,
			BlankObject.Instance,
			BlankObject.Instance,
			BlankObject.Instance
		};

		private static readonly bool[] HotbarCurrentlyFlipped = new bool[9];

		private static readonly float[] HotbarCurrentRotation = new float[9];

		private static readonly float[] HotbarCurrentScale = new float[9] { 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f };

		private static readonly List<(string, string, int)>[] HotbarReceivers = new List<(string, string, int)>[9]
		{
			new List<(string, string, int)>(),
			new List<(string, string, int)>(),
			new List<(string, string, int)>(),
			new List<(string, string, int)>(),
			new List<(string, string, int)>(),
			new List<(string, string, int)>(),
			new List<(string, string, int)>(),
			new List<(string, string, int)>(),
			new List<(string, string, int)>()
		};

		private static readonly List<(string, string)>[] HotbarBroadcasters = new List<(string, string)>[9]
		{
			new List<(string, string)>(),
			new List<(string, string)>(),
			new List<(string, string)>(),
			new List<(string, string)>(),
			new List<(string, string)>(),
			new List<(string, string)>(),
			new List<(string, string)>(),
			new List<(string, string)>(),
			new List<(string, string)>()
		};

		private static readonly Dictionary<string, Architect.Config.Types.ConfigValue>[] HotbarConfig = new Dictionary<string, Architect.Config.Types.ConfigValue>[9]
		{
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>(),
			new Dictionary<string, Architect.Config.Types.ConfigValue>()
		};

		public static bool LoadPos;

		private static Vector3 _posToLoad;

		public static Vector3 NoclipPos;

		private static float _lastX;

		private static float _lastY;

		private static string _validLastPosScene;

		public static ObjectPlacement HoveredObject;

		private static readonly List<(ObjectPlacement, Vector3)> CopiedObjects = new List<(ObjectPlacement, Vector3)>();

		public static readonly List<ObjectPlacement> SelectedObjects = new List<ObjectPlacement>();

		private static bool _dragging;

		private static bool _groupSelecting;

		private static Vector3 _groupSelectionCorner;

		private static GroupSelectionBox _groupSelectionBox;

		private static readonly int Color1 = Shader.PropertyToID("_Color");

		public static int Layer
		{
			[CompilerGenerated]
			get
			{
				return <Layer>k__BackingField;
			}
			set
			{
				<Layer>k__BackingField = value;
				EditorUI.LayerName.text = $"Layer\n{value}";
				EditorUI.LayerToggle.text = ((FlippedLayers.Contains(value) != ShowLayersByDefault) ? "X" : "");
				foreach (ObjectPlacement selectedObject in SelectedObjects)
				{
					selectedObject.SetLayer(value);
				}
				foreach (ObjectPlacement placement in PlacementManager.GetLevelData().Placements)
				{
					placement.RefreshLockColour();
				}
			}
		}

		public static int HotbarIndex
		{
			get
			{
				return _hotbarIndex;
			}
			set
			{
				_hotbarIndex = value;
				EditorUI.WipeTabs();
				EditorUI.RefreshAttributeControls(useDefaultConfig: false);
				EditorUI.RefreshItem();
				EditorUI.RotationText.text = CurrentRotation.ToString(CultureInfo.InvariantCulture);
				EditorUI.ScaleText.text = CurrentScale.ToString(CultureInfo.InvariantCulture);
				CursorManager.NeedsRefresh = true;
				CursorManager.ObjectChanged = true;
			}
		}

		public static SelectableObject CurrentObject
		{
			get
			{
				return HotbarCurrentObject[_hotbarIndex];
			}
			set
			{
				HotbarCurrentObject[_hotbarIndex] = value;
			}
		}

		public static bool CurrentlyFlipped
		{
			get
			{
				return HotbarCurrentlyFlipped[_hotbarIndex];
			}
			set
			{
				HotbarCurrentlyFlipped[_hotbarIndex] = value;
			}
		}

		public static float CurrentRotation
		{
			get
			{
				return HotbarCurrentRotation[_hotbarIndex];
			}
			set
			{
				HotbarCurrentRotation[_hotbarIndex] = value;
			}
		}

		public static float CurrentScale
		{
			get
			{
				return HotbarCurrentScale[_hotbarIndex];
			}
			set
			{
				HotbarCurrentScale[_hotbarIndex] = value;
			}
		}

		public static List<(string, string, int)> Receivers => HotbarReceivers[_hotbarIndex];

		public static List<(string, string)> Broadcasters => HotbarBroadcasters[_hotbarIndex];

		public static Dictionary<string, Architect.Config.Types.ConfigValue> Config => HotbarConfig[_hotbarIndex];

		private static bool HasValidLastPos
		{
			get
			{
				return _validLastPosScene == GameManager.instance.sceneName;
			}
			set
			{
				_validLastPosScene = (value ? GameManager.instance.sceneName : "");
			}
		}

		public static void Init()
		{
			typeof(GameManager).Hook("EnterHero", new Action<Action<GameManager>, GameManager>(OnSceneLoad));
			typeof(InputHandler).Hook("SetCursorVisible", new Action<Action<InputHandler, bool>, InputHandler, bool>(EnableCursor));
			typeof(QuitToMenu).Hook("Start", (Func<Func<QuitToMenu, IEnumerator>, QuitToMenu, IEnumerator>)delegate(Func<QuitToMenu, IEnumerator> orig, QuitToMenu self)
			{
				IsEditing = false;
				return orig(self);
			});
			typeof(HeroController).Hook("CanTakeDamage", new Func<Func<HeroController, bool>, HeroController, bool>(BlockActionOrInvul));
			typeof(HeroController).Hook("CanTakeDamageIgnoreInvul", new Func<Func<HeroController, bool>, HeroController, bool>(BlockActionOrInvul));
			typeof(HeroController).Hook("CanOpenInventory", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => (!Settings.BlockInventoryInEditMode.Value || !IsEditing) && orig(self)));
			typeof(HeroController).Hook("CanDash", new Func<Func<HeroController, bool>, HeroController, bool>(BlockAction));
			typeof(HeroController).Hook("CanHarpoonDash", new Func<Func<HeroController, bool>, HeroController, bool>(BlockAction));
			typeof(PersistentBoolItem).Hook("Awake", (Action<Action<PersistentBoolItem>, PersistentBoolItem>)delegate(Action<PersistentBoolItem> orig, PersistentBoolItem self)
			{
				if (Settings.TestMode.Value && ((Object)((Component)self).gameObject).name.StartsWith("[Architect] "))
				{
					((PersistentItem<bool>)(object)self).OnGetSaveState += delegate(out bool value)
					{
						value = ((PersistentItem<bool>)(object)self).DefaultValue;
					};
					((Behaviour)self).enabled = false;
				}
				orig(self);
			});
			typeof(PersistentIntItem).Hook("Awake", (Action<Action<PersistentIntItem>, PersistentIntItem>)delegate(Action<PersistentIntItem> orig, PersistentIntItem self)
			{
				if (Settings.TestMode.Value && ((Object)((Component)self).gameObject).name.StartsWith("[Architect] "))
				{
					((PersistentItem<int>)(object)self).OnGetSaveState += delegate(out int value)
					{
						value = ((PersistentItem<int>)(object)self).DefaultValue;
					};
					((Behaviour)self).enabled = false;
				}
				orig(self);
			});
			SetupGroupSelectionBox();
		}

		private static bool BlockAction(Func<HeroController, bool> orig, HeroController self)
		{
			return !IsEditing && orig(self);
		}

		private static bool BlockActionOrInvul(Func<HeroController, bool> orig, HeroController self)
		{
			return !InvulBlock.Invulnerable && !IsEditing && orig(self);
		}

		public static void TryFindEmptySlot()
		{
			if (!Input.GetKey((KeyCode)308) || CurrentObject == BlankObject.Instance)
			{
				return;
			}
			for (int i = _hotbarIndex; i < 9; i++)
			{
				if (HotbarCurrentObject[i] == BlankObject.Instance)
				{
					HotbarIndex = i;
					return;
				}
			}
			for (int j = 0; j < _hotbarIndex; j++)
			{
				if (HotbarCurrentObject[j] == BlankObject.Instance)
				{
					HotbarIndex = j;
					break;
				}
			}
		}

		public static void SetRotation(float rotation)
		{
			EditorUI.RotationText.text = (rotation % 360f).ToString(CultureInfo.InvariantCulture);
			CursorManager.NeedsRefresh = true;
		}

		public static void SetScale(float scale)
		{
			EditorUI.ScaleText.text = Mathf.Max(scale, 0.1f).ToString(CultureInfo.InvariantCulture);
			CursorManager.NeedsRefresh = true;
		}

		public static void Update()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			bool isPaused = GameManager.instance.isPaused;
			HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
			if (!isPaused && (!HeroController.instance.controlReqlinquished || IgnoreControlRelinquished) && !LoadPos && !HeroController.instance.cState.dead && (int)HeroController.instance.transitionState == 0 && !Object.op_Implicit((Object)(object)HeroController.instance.transform.parent))
			{
				if (Settings.ToggleEditor.WasPressed && ToggleChecks.All((Func<bool> f) => f()))
				{
					ToggleEditor(!IsEditing);
				}
				else if (ReloadRequired)
				{
					ReloadScene();
				}
			}
			EditorUI.RefreshVisibility(IsEditing, isPaused);
			if (IsEditing || LoadPos)
			{
				DoNoclip(inputActions, isPaused);
			}
			if (!IsEditing)
			{
				return;
			}
			if (isPaused)
			{
				bool wasPressed = ((OneAxisInputControl)inputActions.Left).WasPressed;
				bool wasPressed2 = ((OneAxisInputControl)inputActions.Right).WasPressed;
				if (wasPressed != wasPressed2)
				{
					EditorUI.Shift(wasPressed2 ? 1 : (-1));
				}
			}
			PlayerData.instance.isInvincible = true;
			HeroController.instance.ResetHardLandingTimer();
			if (!isPaused)
			{
				if (Input.GetKeyDown((KeyCode)49))
				{
					HotbarIndex = 0;
				}
				else if (Input.GetKeyDown((KeyCode)50))
				{
					HotbarIndex = 1;
				}
				else if (Input.GetKeyDown((KeyCode)51))
				{
					HotbarIndex = 2;
				}
				else if (Input.GetKeyDown((KeyCode)52))
				{
					HotbarIndex = 3;
				}
				else if (Input.GetKeyDown((KeyCode)53))
				{
					HotbarIndex = 4;
				}
				else if (Input.GetKeyDown((KeyCode)54))
				{
					HotbarIndex = 5;
				}
				else if (Input.GetKeyDown((KeyCode)55))
				{
					HotbarIndex = 6;
				}
				else if (Input.GetKeyDown((KeyCode)56))
				{
					HotbarIndex = 7;
				}
				else if (Input.GetKeyDown((KeyCode)57))
				{
					HotbarIndex = 8;
				}
				foreach (var (keybind2, item) in ToolObject.Keybinds)
				{
					if (keybind2.WasPressed)
					{
						EditorUI.SetItem(item);
					}
				}
			}
			bool flag = false;
			if (CurrentObject is PlaceableObject placeableObject)
			{
				if (!isPaused)
				{
					ApplyEditChanges(placeableObject);
				}
				if (Settings.SaveObject.WasPressed && !(placeableObject is PrefabObject))
				{
					SavedCategory.AddPrefab(new SavedObject(placeableObject.PreparePlacement(Vector3.zero)));
					if (EditorUI.CurrentCategory == SavedCategory.Instance)
					{
						EditorUI.DoRefreshCurrentPage();
					}
				}
				if (Settings.Overwrite.IsPressed || Settings.GrabId.IsPressed)
				{
					flag = true;
				}
			}
			if (!isPaused && (flag || (CurrentObject is ToolObject toolObject && toolObject.Highlight)))
			{
				ObjectPlacement objectPlacement = PlacementManager.FindObject(Input.mousePosition);
				if (HoveredObject != objectPlacement)
				{
					HoveredObject?.ClearColour();
					objectPlacement?.SetHoverColour();
					HoveredObject = objectPlacement;
				}
			}
			else if (HoveredObject != null)
			{
				HoveredObject.ClearColour();
				HoveredObject = null;
			}
			bool mouseButtonDown = Input.GetMouseButtonDown(0);
			bool mouseButtonDown2 = Input.GetMouseButtonDown(1);
			bool mouseButton = Input.GetMouseButton(0);
			if (_groupSelecting)
			{
				RefreshGroupSelection(!mouseButton || isPaused || Settings.Preview.IsPressed);
			}
			bool flag2 = CurrentObject is DragObject;
			if (SelectedObjects.Count > 0)
			{
				if (Settings.Preview.IsPressed || (!(CurrentObject is EraserObject) && !flag2))
				{
					StopIfDragging(release: true);
				}
				else if (_dragging)
				{
					if (!mouseButton)
					{
						StopIfDragging(!Settings.MultiSelect.IsPressed);
					}
					else if (isPaused)
					{
						StopIfDragging(release: true);
					}
					else
					{
						UpdateDragging();
					}
				}
			}
			if (flag2 && !_dragging)
			{
				if (Settings.Copy.WasPressed)
				{
					CopySelection();
				}
				if (Settings.Paste.WasPressed)
				{
					PasteToSelection();
				}
			}
			if (!mouseButton || isPaused)
			{
				ResetObject.RestartDelay();
			}
			if (!isPaused)
			{
				if (mouseButtonDown || mouseButton)
				{
					CurrentObject.Click(Input.mousePosition, mouseButtonDown);
				}
				else if (Input.GetMouseButtonUp(0))
				{
					CurrentObject.Release();
				}
				if (mouseButtonDown2)
				{
					CurrentObject.RightClick(Input.mousePosition);
				}
				if (Settings.Undo.WasPressed)
				{
					ActionManager.UndoLast();
				}
				if (Settings.Redo.WasPressed)
				{
					ActionManager.RedoLast();
				}
			}
		}

		private static void CopySelection()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			CopiedObjects.Clear();
			Vector3 worldPos = GetWorldPos(Input.mousePosition);
			foreach (ObjectPlacement selectedObject in SelectedObjects)
			{
				CopiedObjects.Add((selectedObject, worldPos - selectedObject.GetPos()));
			}
		}

		private static void PasteToSelection()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			StopIfDragging(release: true);
			Vector3 worldPos = GetWorldPos(Input.mousePosition);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (var copiedObject in CopiedObjects)
			{
				ObjectPlacement item = copiedObject.Item1;
				dictionary[item.GetId()] = Guid.NewGuid().ToString().Substring(0, 8);
			}
			List<ObjectPlacement> list = new List<ObjectPlacement>();
			foreach (var copiedObject2 in CopiedObjects)
			{
				ObjectPlacement item2 = copiedObject2.Item1;
				Vector3 item3 = copiedObject2.Item2;
				List<Architect.Config.Types.ConfigValue> list2 = new List<Architect.Config.Types.ConfigValue>();
				Architect.Config.Types.ConfigValue[] config = item2.Config;
				foreach (Architect.Config.Types.ConfigValue configValue in config)
				{
					Architect.Config.Types.ConfigValue configValue2 = configValue;
					Architect.Config.Types.ConfigValue configValue3 = configValue2;
					if (!(configValue3 is StringConfigValue stringConfigValue))
					{
						if (configValue3 is IdConfigValue idConfigValue)
						{
							string value = idConfigValue.GetValue();
							list2.Add(dictionary.TryGetValue(value, out var value2) ? Architect.Config.ConfigurationManager.DeserializeConfigValue(configValue.GetTypeId(), value2) : configValue);
						}
						else
						{
							list2.Add(configValue);
						}
					}
					else
					{
						string value3 = stringConfigValue.GetValue();
						list2.Add(dictionary.TryGetValue(value3, out var value4) ? Architect.Config.ConfigurationManager.DeserializeConfigValue(configValue.GetTypeId(), value4) : configValue);
					}
				}
				list.Add(new ObjectPlacement(item2.GetPlacementType(), worldPos - item3, dictionary[item2.GetId()], item2.IsFlipped(), item2.GetRotation(), item2.GetScale(), locked: false, Layer, item2.Broadcasters, item2.Receivers, list2.ToArray()));
			}
			ActionManager.PerformAction(new PlaceObjects(list));
			foreach (ObjectPlacement item4 in list)
			{
				ToggleSelectedObject(item4, startDragging: false);
			}
		}

		private static void EnableCursor(Action<InputHandler, bool> orig, InputHandler self, bool value)
		{
			if (IsEditing)
			{
				if (!GameManager.instance.isPaused && CurrentObject is PlaceableObject)
				{
					Cursor.visible = false;
					Cursor.lockState = (CursorLockMode)0;
				}
				else
				{
					orig(self, arg2: true);
				}
			}
			else
			{
				orig(self, value);
			}
		}

		private static void ApplyEditChanges(PlaceableObject placeable)
		{
			SelectableObject currentObject = CurrentObject;
			if (currentObject == null || currentObject.DisableTransformations)
			{
				return;
			}
			if (Settings.Flip.WasPressed)
			{
				CurrentlyFlipped = !CurrentlyFlipped;
				CursorManager.NeedsRefresh = true;
			}
			if (Settings.ScaleUp.IsPressed)
			{
				SetScale(CurrentScale + Time.deltaTime);
			}
			if (Settings.ScaleDown.IsPressed)
			{
				SetScale(CurrentScale - Time.deltaTime);
			}
			RotationGroup rotationGroup = placeable.GetRotationGroup();
			if (Settings.UnsafeRotation.IsPressed)
			{
				rotationGroup = RotationGroup.All;
			}
			float num;
			if (rotationGroup == RotationGroup.All && Settings.Rotate.IsPressed)
			{
				num = Time.deltaTime * 60f;
			}
			else
			{
				if (!Settings.Rotate.WasPressed)
				{
					return;
				}
				if (1 == 0)
				{
				}
				int num2 = rotationGroup switch
				{
					RotationGroup.Vertical => 180, 
					RotationGroup.Three => 90, 
					RotationGroup.Four => 90, 
					RotationGroup.Eight => 45, 
					_ => 0, 
				};
				if (1 == 0)
				{
				}
				num = num2;
			}
			if (Settings.InvertRotate.IsPressed)
			{
				num = 0f - num;
			}
			float num3 = CurrentRotation + num;
			if (rotationGroup == RotationGroup.Three && Mathf.Approximately(num3, 180f))
			{
				num3 = 270f;
			}
			SetRotation(num3);
		}

		public static void ToggleEditor(bool target)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			if (IsEditing == target || !PreloadManager.HasPreloaded || PrefabManager.InPrefabScene || Time.time - _lastEditToggle < 1f)
			{
				return;
			}
			IgnoreControlRelinquished = false;
			NoclipPos = HeroController.instance.transform.position;
			if (IsEditing && _dragging)
			{
				StopIfDragging(release: true);
			}
			if (IsEditing && Input.GetMouseButton(0))
			{
				CurrentObject.Release();
			}
			_lastEditToggle = Time.time;
			Scene activeScene = SceneManager.GetActiveScene();
			foreach (TransitionPoint item in ((Scene)(ref activeScene)).GetRootGameObjects().SelectMany((GameObject o) => o.GetComponentsInChildren<TransitionPoint>()))
			{
				((Component)item).gameObject.SetActive(false);
			}
			IsEditing = !IsEditing;
			InvulBlock.Invulnerable = false;
			EditorUI.DoRefreshCurrentPage();
			GlobalArchitectData.Instance.CurrentMapId = "";
			HeroController.instance.ExitUpdraft();
			if (!IsEditing)
			{
				PlayerData.instance.isInvincible = false;
			}
			else
			{
				Transform val = ((Component)GameManager.instance.gameCams).gameObject.transform.Find("Roar Wave Emitter Small");
				if (Object.op_Implicit((Object)(object)val))
				{
					((Component)val).transform.position = new Vector3(-99999f, -99999f);
				}
				Transform val2 = ((Component)GameManager.instance.gameCams).gameObject.transform.Find("Roar Wave Emitter");
				if (Object.op_Implicit((Object)(object)val2))
				{
					((Component)val2).transform.position = new Vector3(-99999f, -99999f);
				}
				ScreenFaderUtils.SetColour(Color.clear);
				GameCameras.instance.HUDIn();
			}
			ReloadScene();
			StorageManager.SaveScene(GameManager.instance.sceneName, PlacementManager.GetLevelData());
			StorageManager.SaveScene("Global", PlacementManager.GetGlobalData());
			StorageManager.SaveWorkshopData();
		}

		private static void OnSceneLoad(Action<GameManager> orig, GameManager self)
		{
			//IL_0038: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (self.sceneName == "Temp")
			{
				return;
			}
			if (LoadPos)
			{
				self.entryGateName = null;
				HeroController.instance.transform.position = _posToLoad;
				LoadPos = false;
				NoclipPos = _posToLoad;
				if (CoopManager.Instance.IsActive())
				{
					CoopManager.Instance.RefreshRoom();
				}
				GameManager.instance.cameraCtrl.StopFreeze(false);
				Scene activeScene = SceneManager.GetActiveScene();
				CameraLockArea val = ((Scene)(ref activeScene)).GetRootGameObjects().SelectMany((GameObject o) => o.GetComponentsInChildren<CameraLockArea>()).FirstOrDefault((Func<CameraLockArea, bool>)((CameraLockArea o) => ((TrackTriggerObjects)o).InsideCount > 0));
				if (Object.op_Implicit((Object)(object)val))
				{
					((TrackTriggerObjects)val).OnInsideStateChanged(true);
				}
			}
			if (HoveredObject != null)
			{
				HoveredObject.ClearColour();
				HoveredObject = null;
			}
			SelectedObjects.Clear();
			_groupSelecting = false;
			((Component)_groupSelectionBox).gameObject.SetActive(false);
			orig(self);
		}

		public static void ReloadScene()
		{
			//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)
			ReloadRequired = false;
			IgnoreControlRelinquished = false;
			LoadPos = true;
			_posToLoad = HeroController.instance.transform.position;
			GameManager.instance.ChangeToScene(GameManager.instance.sceneName, "", 0f);
		}

		private static void DoNoclip(HeroActions actions, bool paused)
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Invalid comparison between Unknown and I4
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			bool isPressed = ((OneAxisInputControl)actions.Up).IsPressed;
			bool isPressed2 = ((OneAxisInputControl)actions.Down).IsPressed;
			bool isPressed3 = ((OneAxisInputControl)actions.Left).IsPressed;
			bool isPressed4 = ((OneAxisInputControl)actions.Right).IsPressed;
			int num = (((OneAxisInputControl)actions.Dash).IsPressed ? 35 : 20);
			if (!LoadPos)
			{
				if (!paused && isPressed != isPressed2)
				{
					NoclipPos += (isPressed ? Vector3.up : Vector3.down) * (Time.deltaTime * (float)num);
				}
				if (!paused && isPressed3 != isPressed4)
				{
					NoclipPos += (isPressed3 ? Vector3.left : Vector3.right) * (Time.deltaTime * (float)num);
				}
			}
			if ((int)HeroController.instance.transitionState == 0)
			{
				HeroController.instance.transform.position = NoclipPos;
			}
			else
			{
				NoclipPos = HeroController.instance.transform.position;
			}
		}

		public static void RegisterLastPos(Vector2 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			_lastX = pos.x;
			_lastY = pos.y;
			HasValidLastPos = true;
		}

		public static Vector3 GetWorldPos(Vector3 mousePosition, bool lockAxisApplies = false, float offset = 0f)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			Camera cam = GameCameras.instance.cameraController.cam;
			mousePosition.z = 0f - ((Component)cam).transform.position.z + offset;
			Vector3 val = cam.ScreenToWorldPoint(mousePosition);
			if (lockAxisApplies && Settings.LockAxis.IsPressed && HasValidLastPos)
			{
				if (Math.Abs(_lastX - val.x) > Math.Abs(_lastY - val.y))
				{
					val.y = _lastY;
				}
				else
				{
					val.x = _lastX;
				}
			}
			return val;
		}

		public static void ClearAttributes()
		{
			Broadcasters.Clear();
			Receivers.Clear();
			Config.Clear();
		}

		public static void ToggleSelectedObject(ObjectPlacement placement, bool startDragging)
		{
			if (Settings.Preview.IsPressed)
			{
				return;
			}
			if (SelectedObjects.Contains(placement))
			{
				SelectedObjects.Remove(placement);
				placement.ClearColour();
				return;
			}
			SelectedObjects.Add(placement);
			placement.SetDraggedColour();
			if (startDragging)
			{
				BeginDragging();
			}
		}

		public static void StartGroupSelect()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			_groupSelectionCorner = GetWorldPos(Input.mousePosition);
			_groupSelecting = true;
			((Component)_groupSelectionBox).gameObject.SetActive(true);
			((Component)_groupSelectionBox).transform.position = _groupSelectionCorner;
			_groupSelectionBox.width = 0f;
			_groupSelectionBox.height = 0f;
			_groupSelectionBox.UpdateOutline();
		}

		private static void StopGroupSelect(Vector3 worldPos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			((Component)_groupSelectionBox).gameObject.SetActive(false);
			foreach (ObjectPlacement item in PlacementManager.GetLevelData().Placements.Where((ObjectPlacement obj) => obj.IsWithinZone(Vector2.op_Implicit(_groupSelectionCorner), Vector2.op_Implicit(worldPos))))
			{
				ToggleSelectedObject(item, startDragging: false);
			}
			_groupSelecting = false;
		}

		private static void RefreshGroupSelection(bool release)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Vector3 worldPos = GetWorldPos(Input.mousePosition);
			if (release)
			{
				StopGroupSelect(worldPos);
				return;
			}
			_groupSelectionBox.width = worldPos.x - _groupSelectionCorner.x;
			_groupSelectionBox.height = worldPos.y - _groupSelectionCorner.y;
			_groupSelectionBox.UpdateOutline();
		}

		public static void BeginDragging()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			_dragging = true;
			Vector3 worldPos = GetWorldPos(Input.mousePosition);
			foreach (ObjectPlacement selectedObject in SelectedObjects)
			{
				selectedObject.StartMove(worldPos);
			}
		}

		private static void UpdateDragging()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Vector3 worldPos = GetWorldPos(Input.mousePosition);
			foreach (ObjectPlacement selectedObject in SelectedObjects)
			{
				selectedObject.Move(worldPos);
			}
		}

		public static void StopIfDragging(bool release)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			List<(ObjectPlacement, Vector3, Vector3)> list = new List<(ObjectPlacement, Vector3, Vector3)>();
			foreach (ObjectPlacement selectedObject in SelectedObjects)
			{
				list.Add((selectedObject, selectedObject.GetPos(), selectedObject.FinishMove()));
				if (release)
				{
					selectedObject.ClearColour();
				}
			}
			if (_dragging)
			{
				ActionManager.PerformAction(new MoveObjects(list));
				_dragging = false;
			}
			if (release)
			{
				SelectedObjects.Clear();
			}
		}

		private static void SetupGroupSelectionBox()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("[Architect] Group Selection Box");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			Material val2 = new Material(Shader.Find("Sprites/Default"));
			val2.SetColor(Color1, new Color(0f, 1f, 0f, 0.3f));
			((Renderer)val.AddComponent<LineRenderer>()).material = val2;
			_groupSelectionBox = val.AddComponent<GroupSelectionBox>();
		}
	}
	public static class EditorUI
	{
		public class ChoiceButton : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			public Action OnLeftClick;

			public Action OnRightClick;

			public void OnPointerClick(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected I4, but got Unknown
				InputButton button = eventData.button;
				InputButton val = button;
				switch ((int)val)
				{
				case 0:
					OnLeftClick();
					break;
				case 1:
					OnRightClick();
					break;
				case 2:
					break;
				default:
					throw new ArgumentOutOfRangeException();
				}
			}
		}

		private enum AttributeType
		{
			Config,
			Events,
			Listeners
		}

		private enum EditorType
		{
			Map,
			Script,
			Workshop
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__42_0;

			public static UnityAction <>9__42_1;

			public static UnityAction <>9__43_3;

			public static Func<Architect.Config.Types.ConfigType, Architect.Config.Types.ConfigValue> <>9__49_0;

			public static Func<Architect.Config.Types.ConfigValue, bool> <>9__49_1;

			public static Func<Architect.Config.Types.ConfigValue, bool> <>9__67_0;

			public static Func<SelectableObject, bool> <>9__70_0;

			public static Func<char, bool> <>9__70_1;

			public static UnityAction<string> <>9__72_0;

			public static UnityAction<string> <>9__73_0;

			public static UnityAction<string> <>9__73_1;

			public static UnityAction <>9__79_0;

			public static UnityAction <>9__79_1;

			public static UnityAction <>9__79_2;

			public static UnityAction <>9__79_3;

			public static UnityAction <>9__79_4;

			internal void <SetupObjects>b__42_0()
			{
				if (CoopManager.Instance.IsActive())
				{
					CoopManager.Instance.ShareScene(GameManager.instance.sceneName, scriptOnly: false, PlacementManager.GetLevelData());
				}
			}

			internal void <SetupObjects>b__42_1()
			{
				if (CoopManager.Instance.IsActive())
				{
					CoopManager.Instance.ShareScene(ScriptManager.IsLocal ? GameManager.instance.sceneName : "Global", scriptOnly: true, ScriptManager.IsLocal ? PlacementManager.GetLevelData() : PlacementManager.GetGlobalData());
				}
			}

			internal void <SetupPrefabButton>b__43_3()
			{
				PageIndex = 0;
				CurrentCategory = PrefabsCategory.Instance;
				DoRefreshCurrentPage();
			}

			internal Architect.Config.Types.ConfigValue <RefreshAttributeControls>b__49_0(Architect.Config.Types.ConfigType configType)
			{
				return configType.GetDefaultValue();
			}

			internal bool <RefreshAttributeControls>b__49_1(Architect.Config.Types.ConfigValue val)
			{
				return val != null;
			}

			internal bool <RefreshItem>b__67_0(Architect.Config.Types.ConfigValue c)
			{
				return c.GetTypeId() == "png_url";
			}

			internal bool <RefreshCurrentPage>b__70_0(SelectableObject obj)
			{
				return obj.GetName().IndexOf(_currentSearch, StringComparison.OrdinalIgnoreCase) >= 0;
			}

			internal bool <RefreshCurrentPage>b__70_1(char c)
			{
				switch (c)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
				case 'G':
				case 'H':
				case 'I':
				case 'J':
				case 'K':
				case 'L':
				case 'M':
				case 'N':
				case 'O':
				case 'P':
				case 'Q':
				case 'R':
				case 'S':
				case 'T':
				case 'U':
				case 'V':
				case 'W':
				case 'X':
				case 'Y':
				case 'Z':
					return true;
				default:
					return false;
				}
			}

			internal void <SetupSearchBox>b__72_0(string s)
			{
				PageIndex = 0;
				_currentSearch = s;
				DoRefreshCurrentPage();
			}

			internal void <SetupPreciseSettings>b__73_0(string s)
			{
				try
				{
					EditManager.CurrentRotation = Convert.ToSingle(s, CultureInfo.InvariantCulture);
				}
				catch (FormatException)
				{
					EditManager.SetRotation(0f);
				}
				CursorManager.NeedsRefresh = true;
			}

			internal void <SetupPreciseSettings>b__73_1(string s)
			{
				try
				{
					EditManager.CurrentScale = Convert.ToSingle(s, CultureInfo.InvariantCulture);
				}
				catch (FormatException)
				{
					EditManager.SetScale(1f);
				}
				CursorManager.NeedsRefresh = true;
			}

			internal void <SetupLayers>b__79_0()
			{
				EditManager.ShowLayersByDefault = true;
				EditManager.FlippedLayers.Clear();
				EditManager.Layer = EditManager.Layer;
			}

			internal void <SetupLayers>b__79_1()
			{
				EditManager.ShowLayersByDefault = false;
				EditManager.FlippedLayers.Clear();
				EditManager.Layer = EditManager.Layer;
			}

			internal void <SetupLayers>b__79_2()
			{
				if (!EditManager.FlippedLayers.Remove(EditManager.Layer))
				{
					EditManager.FlippedLayers.Add(EditManager.Layer);
				}
				EditManager.Layer = EditManager.Layer;
			}

			internal void <SetupLayers>b__79_3()
			{
				EditManager.Layer = Math.Max(0, EditManager.Layer - 1);
			}

			internal void <SetupLayers>b__79_4()
			{
				EditManager.Layer++;
			}
		}

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

			private object <>2__current;

			public int id;

			private int <i>5__1;

			private int <index>5__2;

			private (Image, UIUtils.Label, UIUtils.Label) <icon>5__3;

			private float <rot>5__4;

			private PlaceableObject <placeable>5__5;

			private string <text>5__6;

			private bool <favourite>5__7;

			private PrefabObject <obj>5__8;

			private PlaceableObject <obj>5__9;

			private SavedObject <prefab>5__10;

			private SelectableObject <>s__11;

			private char[] <name>5__12;

			private SpritePackingRotation <>s__13;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<icon>5__3 = default((Image, UIUtils.Label, UIUtils.Label));
				<placeable>5__5 = null;
				<text>5__6 = null;
				<obj>5__8 = null;
				<obj>5__9 = null;
				<prefab>5__10 = null;
				<>s__11 = null;
				<name>5__12 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_050e: Expected I4, but got Unknown
				//IL_026f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_021d: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_02f8;
				}
				<>1__state = -1;
				_categoryContents = (from obj in CurrentCategory.GetObjects()
					where obj.GetName().IndexOf(_currentSearch, StringComparison.OrdinalIgnoreCase) >= 0
					select obj).ToList();
				<i>5__1 = 0;
				goto IL_05cd;
				IL_05ae:
				<icon>5__3 = default((Image, UIUtils.Label, UIUtils.Label));
				goto IL_05bb;
				IL_05cd:
				if (<i>5__1 < 9)
				{
					<index>5__2 = PageIndex * 9 + <i>5__1;
					<icon>5__3 = GridIcons[<i>5__1];
					if (_categoryContents.Count <= <index>5__2)
					{
						<icon>5__3.Item1.sprite = ArchitectPlugin.BlankSprite;
						((Text)<icon>5__3.Item2.textComponent).text = "Unset";
						((Text)<icon>5__3.Item2.textComponent).fontSize = 14;
						((Text)<icon>5__3.Item3.textComponent).text = " ";
						goto IL_05ae;
					}
					<rot>5__4 = 0f;
					SelectableObject selectableObject = _categoryContents[<index>5__2];
					<>s__11 = selectableObject;
					<obj>5__8 = <>s__11 as PrefabObject;
					if (<obj>5__8 == null)
					{
						<obj>5__9 = <>s__11 as PlaceableObject;
						if (<obj>5__9 == null)
						{
							<prefab>5__10 = <>s__11 as SavedObject;
							if (<prefab>5__10 == null)
							{
								goto IL_05bb;
							}
							<placeable>5__5 = <prefab>5__10.PlaceableObject;
							((Text)<icon>5__3.Item3.textComponent).text = "X";
							((Graphic)<icon>5__3.Item3.textComponent).color = Color.red;
							<rot>5__4 = <prefab>5__10.Placement.GetRotation();
						}
						else
						{
							<placeable>5__5 = <obj>5__9;
							<favourite>5__7 = FavouritesCategory.IsFavourite(<placeable>5__5);
							((Text)<icon>5__3.Item3.textComponent).text = (<favourite>5__7 ? "★" : "☆");
							((Graphic)<icon>5__3.Item3.textComponent).color = (<favourite>5__7 ? Color.yellow : Color.white);
						}
					}
					else
					{
						<placeable>5__5 = <obj>5__8;
						((Text)<icon>5__3.Item3.textComponent).text = "";
					}
					<obj>5__8 = null;
					<obj>5__9 = null;
					<prefab>5__10 = null;
					<>s__11 = null;
					if (<placeable>5__5 is PreloadObject preloadObject && !preloadObject.Loaded)
					{
						<>2__current = <placeable>5__5.EnsureLoaded();
						<>1__state = 1;
						return true;
					}
					goto IL_02f8;
				}
				return false;
				IL_02f8:
				if (id != _refreshRoutineId)
				{
					return false;
				}
				((Component)<icon>5__3.Item1).gameObject.SetActive(!(<placeable>5__5 is PrefabObject));
				<icon>5__3.Item1.sprite = _categoryContents[<index>5__2].GetUISprite();
				<text>5__6 = "";
				if (<placeable>5__5 is PrefabObject)
				{
					((Component)<icon>5__3.Item1).gameObject.SetActive(false);
					((Text)<icon>5__3.Item2.textComponent).fontSize = 32;
					string name = <placeable>5__5.GetName();
					<name>5__12 = name.Substring(0, name.Length - 9).ToArray();
					<name>5__12[0] = char.ToUpper(<name>5__12[0]);
					<text>5__6 = string.Concat(<name>5__12.Where(delegate(char c)
					{
						switch (c)
						{
						case '0':
						case '1':
						case '2':
						case '3':
						case '4':
						case '5':
						case '6':
						case '7':
						case '8':
						case '9':
						case 'A':
						case 'B':
						case 'C':
						case 'D':
						case 'E':
						case 'F':
						case 'G':
						case 'H':
						case 'I':
						case 'J':
						case 'K':
						case 'L':
						case 'M':
						case 'N':
						case 'O':
						case 'P':
						case 'Q':
						case 'R':
						case 'S':
						case 'T':
						case 'U':
						case 'V':
						case 'W':
						case 'X':
						case 'Y':
						case 'Z':
							return true;
						default:
							return false;
						}
					}));
					if (<text>5__6.Length > 4)
					{
						<text>5__6 = <text>5__6.Substring(0, 4);
					}
					<name>5__12 = null;
				}
				else
				{
					((Component)<icon>5__3.Item1).gameObject.SetActive(true);
					((Text)<icon>5__3.Item2.textComponent).fontSize = 14;
				}
				((Text)<icon>5__3.Item2.textComponent).text = <text>5__6;
				Extensions.SetScaleX(((Component)<icon>5__3.Item1).transform, 1f);
				Extensions.SetScaleY(((Component)<icon>5__3.Item1).transform, 1f);
				SpritePackingRotation packingRotation = <placeable>5__5.GetUISprite().packingRotation;
				<>s__13 = packingRotation;
				SpritePackingRotation val = <>s__13;
				switch (val - 1)
				{
				case 0:
					Extensions.SetScaleX(((Component)<icon>5__3.Item1).transform, -1f);
					break;
				case 1:
					Extensions.SetScaleY(((Component)<icon>5__3.Item1).transform, -1f);
					break;
				case 2:
					<rot>5__4 += 180f;
					break;
				}
				Extensions.SetRotation2D(((Component)<icon>5__3.Item1).transform, <rot>5__4 + <placeable>5__5.Rotation + <placeable>5__5.ChildRotation + (float)<placeable>5__5.Tk2dRotation);
				<placeable>5__5 = null;
				<text>5__6 = null;
				goto IL_05ae;
				IL_05bb:
				<i>5__1++;
				goto IL_05cd;
			}

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

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

		private const int ITEMS_PER_PAGE = 9;

		private const string FILLED_STAR = "★";

		private const string EMPTY_STAR = "☆";

		private const string BIN = "X";

		private const string NOTHING = " ";

		public static Text ResetRocketTime;

		private static readonly List<(Image, UIUtils.Label, UIUtils.Label)> GridIcons = new List<(Image, UIUtils.Label, UIUtils.Label)>();

		private static readonly List<Image> HotbarIcons = new List<Image>();

		private static readonly List<GameObject> DisableWhenPlaying = new List<GameObject>();

		private static readonly List<GameObject> EnableWhenPlaying = new List<GameObject>();

		private static GameObject _canvasObj;

		private static GameObject _mapUI;

		private static RectTransform _mapTransform;

		private static GameObject _scriptUI;

		private static GameObject _workshopUI;

		public static AbstractCategory CurrentCategory = Categories.All;

		public static int PageIndex;

		private static List<SelectableObject> _categoryContents;

		private static UIUtils.Label _currentlySelected;

		private static UIUtils.Label _currentlySelectedDesc;

		public static UIUtils.Label ObjectIdLabel;

		public static InputField RotationText;

		public static InputField ScaleText;

		private static string _currentSearch = "";

		private static (Button, UIUtils.Label) _configButton;

		private static (Button, UIUtils.Label) _broadcastersButton;

		private static (Button, UIUtils.Label) _receiversButton;

		private static (Button, UIUtils.Label) _mapButton;

		private static (Button, UIUtils.Label) _scriptButton;

		private static (Button, UIUtils.Label) _workshopButton;

		private static GameObject _shareLevelButton;

		private static GameObject _shareLevelLabel;

		private static GameObject _shareScriptButton;

		private static GameObject _shareScriptLabel;

		private static AttributeType _currentOption = AttributeType.Config;

		private static EditorType _currentType = EditorType.Map;

		private static (Button, UIUtils.Label) _legacyCategory;

		private static RectTransform _configTransform;

		private static GameObject _configTab;

		public static readonly List<(InputField, Action)> ConfigIds = new List<(InputField, Action)>();

		private static GameObject _broadcasterTab;

		private static GameObject _receiverTab;

		private static int _receiverCount;

		private static int _broadcasterCount;

		private static int _refreshRoutineId;

		public static Text LayerName;

		public static Text LayerToggle;

		public static void Setup()
		{
			SetupCanvas();
			SetupLabels();
			SetupObjects();
			SetupSearchBox();
			SetupPreciseSettings();
			SetupAttributeSettings();
			SetupHotbar();
			SetupLayers();
			RefreshItem();
		}

		private static void SetupCanvas()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: 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_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			_canvasObj = new GameObject("[Architect] Editor Canvas");
			_canvasObj.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			_canvasObj.AddComponent<Canvas>().renderMode = (RenderMode)0;
			_canvasObj.AddComponent<CanvasScaler>().uiScaleMode = (ScaleMode)1;
			_canvasObj.AddComponent<GraphicRaycaster>();
			GameObject val = new GameObject("Map Editor UI");
			val.transform.parent = _canvasObj.transform;
			_mapUI = val;
			_mapUI.SetActive(false);
			_mapTransform = _mapUI.AddComponent<RectTransform>();
			_mapTransform.anchorMax = Vector2.one;
			_mapTransform.anchorMin = Vector2.zero;
			_mapTransform.offsetMax = Vector2.zero;
			_mapTransform.offsetMin = Vector2.zero;
			if (!Settings.LegacyEventSystem.Value)
			{
				_mapTransform.anchoredPosition = new Vector2(0f, 20f);
			}
			GameObject val2 = new GameObject("Script Editor UI");
			val2.transform.parent = _canvasObj.transform;
			_scriptUI = val2;
			_scriptUI.SetActive(false);
			RectTransform val3 = _scriptUI.AddComponent<RectTransform>();
			val3.anchorMax = Vector2.one;
			val3.anchorMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			val3.offsetMin = Vector2.zero;
			val3.anchoredPosition = new Vector2(0f, 20f);
			ScriptEditorUI.Init(_scriptUI);
			GameObject val4 = new GameObject("Workshop UI");
			val4.transform.parent = _canvasObj.transform;
			_workshopUI = val4;
			_workshopUI.SetActive(false);
			RectTransform val5 = _workshopUI.AddComponent<RectTransform>();
			val5.anchorMax = Vector2.one;
			val5.anchorMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			val5.offsetMin = Vector2.zero;
			val5.anchoredPosition = new Vector2(0f, 60f);
			WorkshopUI.Init(_workshopUI);
			_mapButton = SetupModeButton(EditorType.Map, "Map Editor", new Vector3(-263.5f, 15f));
			_scriptButton = SetupModeButton(EditorType.Script, "Script Editor", new Vector3(0f, 15f));
			_workshopButton = SetupModeButton(EditorType.Workshop, "Workshop", new Vector3(263.5f, 15f));
		}

		private static (Button, UIUtils.Label) SetupModeButton(EditorType type, string name, Vector3 pos)
		{
			//IL_0030: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			Vector2 size = default(Vector2);
			((Vector2)(ref size))..ctor(765f, 50f);
			var (val, label) = UIUtils.MakeTextButton(name + " Button", name, _canvasObj, Vector2.op_Implicit(pos), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, size);
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				_currentType = type;
				UIManager.instance.uiState = (UIState)((type == EditorType.Map) ? 5 : 6);
				Deletable.DeleteButton.SetActive(false);
			});
			((Text)label.textComponent).fontSize = 10;
			DisableWhenPlaying.Add(((Component)val).gameObject);
			DisableWhenPlaying.Add(((Component)label).gameObject);
			return (val, label);
		}

		private static void SetupLabels()
		{
			//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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 1f);
			_currentlySelected = UIUtils.MakeLabel("Current Object Name", _canvasObj, Vector2.op_Implicit(new Vector3(0f, -50f, 0f)), val, val, 80f, 80f, (HorizontalWrapMode)1);
			_currentlySelectedDesc = UIUtils.MakeLabel("Current Object Description", _canvasObj, Vector2.op_Implicit(new Vector3(0f, -70f, 0f)), val, val, 80f, 80f, (HorizontalWrapMode)1);
			((Text)_currentlySelected.textComponent).alignment = (TextAnchor)1;
			((Text)_currentlySelectedDesc.textComponent).alignment = (TextAnchor)1;
			((Text)_currentlySelectedDesc.textComponent).verticalOverflow = (VerticalWrapMode)1;
			((Text)_currentlySelectedDesc.textComponent).fontSize = 10;
			UIUtils.Label currentScene = UIUtils.MakeLabel("Current Scene", _canvasObj, Vector2.op_Implicit(new Vector3(50f, 45f, 0f)), Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1);
			UIUtils.Label inTestMode = UIUtils.MakeLabel("Test Mode", _canvasObj, Vector2.op_Implicit(new Vector3(-50f, 45f, 0f)), new Vector2(1f, 0f), new Vector2(1f, 0f), 80f, 80f, (HorizontalWrapMode)1);
			((Text)currentScene.textComponent).alignment = (TextAnchor)6;
			((Text)inTestMode.textComponent).alignment = (TextAnchor)8;
			((Text)inTestMode.textComponent).text = "Test Mode";
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				((Text)currentScene.textComponent).text = "Scene: " + GameManager.instance.sceneName;
			});
			((Text)inTestMode.textComponent).text = (Settings.TestMode.Value ? "Test Mode" : "");
			Settings.TestMode.SettingChanged += delegate
			{
				((Text)inTestMode.textComponent).text = (Settings.TestMode.Value ? "Test Mode" : "");
			};
			EnableWhenPlaying.Add(((Component)currentScene).gameObject);
			EnableWhenPlaying.Add(((Component)inTestMode).gameObject);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0f);
			ObjectIdLabel = UIUtils.MakeLabel("Object ID Description", _canvasObj, Vector2.op_Implicit(new Vector3(0f, 100f, 0f)), val2, val2, 80f, 80f, (HorizontalWrapMode)1);
			((Text)ObjectIdLabel.textComponent).fontSize = 10;
			((Text)ObjectIdLabel.textComponent).alignment = (TextAnchor)7;
		}

		public static void SetupCategories()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 0f);
			Vector2 pos = default(Vector2);
			((Vector2)(ref pos))..ctor(-25f, 135f);
			foreach (AbstractCategory category in Categories.AllCategories)
			{
				pos.y += 12f;
				if (category.GetName() != null)
				{
					var (val2, item) = UIUtils.MakeTextButton(category.GetName(), category.GetName(), _mapUI, pos, val, val);
					if (category.GetName() == "Legacy")
					{
						_legacyCategory = (val2, item);
					}
					((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
					{
						PageIndex = 0;
						CurrentCategory = category;
						DoRefreshCurrentPage();
					});
				}
			}
		}

		private static void SetupObjects()
		{
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Expected O, but got Unknown
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 0f);
			for (int num = 2; num >= 0; num--)
			{
				for (int num2 = 2; num2 >= 0; num2--)
				{
					int index = 8 - num2 - num * 3;
					var (val2, item, item2) = UIUtils.MakeButtonWithImage("Option " + index, _mapUI, Vector2.op_Implicit(new Vector3((float)(-25 - num2 * 40), (float)(25 + num * 40))), val, val, 96, 60);
					var (val3, favLabel) = UIUtils.MakeTextButton("Favourite " + index, " ", _mapUI, Vector2.op_Implicit(new Vector3((float)(-45 - num2 * 40), (float)(25 + num * 40))), val, val, hasOutline: false);
					((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
					{
						SetItem(index);
					});
					((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
					{
						ToggleFavourite(index, favLabel);
					});
					GridIcons.Add((item, item2, favLabel));
				}
			}
			MakeToolButton(CursorObject.Instance, 230, 40);
			MakeToolButton(EraserObject.Instance, 190, 40);
			MakeToolButton(PickObject.Instance, 150, 40);
			MakeToolButton(DragObject.Instance, 250, 0);
			MakeToolButton(LockObject.Instance, 210, 0);
			MakeToolButton(TileChangerObject.Instance, 170, 0);
			MakeToolButton(ResetObject.Instance, 130, 0);
			SetupPrefabButton();
			(Button, UIUtils.Label) tuple3 = UIUtils.MakeTextButton("Share Level", "Share Room (" + CoopManager.Instance.Name + ")", _mapUI, Vector2.op_Implicit(new Vector3(-215f, 95f)), new Vector2(1f, 0f), new Vector2(1f, 0f), hasOutline: true, new Vector2(250f, 35f));
			_shareLevelButton = ((Component)tuple3.Item1).gameObject;
			_shareLevelLabel = ((Component)tuple3.Item2).gameObject;
			(Button, UIUtils.Label) tuple4 = UIUtils.MakeTextButton("Share Script", "Share Script (" + CoopManager.Instance.Name + ")", _scriptUI, Vector2.op_Implicit(new Vector3(0f, 20f)), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(250f, 35f));
			_shareScriptButton = ((Component)tuple4.Item1).gameObject;
			_shareScriptLabel = ((Component)tuple4.Item2).gameObject;
			_shareScriptLabel.transform.parent = _shareScriptButton.transform;
			ButtonClickedEvent onClick = tuple3.Item1.onClick;
			object obj = <>c.<>9__42_0;
			if (obj == null)
			{
				UnityAction val4 = delegate
				{
					if (CoopManager.Instance.IsActive())
					{
						CoopManager.Instance.ShareScene(GameManager.instance.sceneName, scriptOnly: false, PlacementManager.GetLevelData());
					}
				};
				<>c.<>9__42_0 = val4;
				obj = (object)val4;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = tuple4.Item1.onClick;
			object obj2 = <>c.<>9__42_1;
			if (obj2 == null)
			{
				UnityAction val5 = delegate
				{
					if (CoopManager.Instance.IsActive())
					{
						CoopManager.Instance.ShareScene(ScriptManager.IsLocal ? GameManager.instance.sceneName : "Global", scriptOnly: true, ScriptManager.IsLocal ? PlacementManager.GetLevelData() : PlacementManager.GetGlobalData());
					}
				};
				<>c.<>9__42_1 = val5;
				obj2 = (object)val5;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			Vector2 val6 = default(Vector2);
			((Vector2)(ref val6))..ctor(0.5f, 0.5f);
			ResetRocketTime = (Text)(object)UIUtils.MakeLabel("Reset Time", _canvasObj, Vector2.op_Implicit(Vector3.zero), val6, val6, 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Behaviour)ResetRocketTime).enabled = false;
			ResetRocketTime.alignment = (TextAnchor)4;
			ResetRocketTime.fontSize = 60;
		}

		private static void SetupPrefabButton()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Expected O, but got Unknown
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: 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_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Expected O, but got Unknown
			(Button, Image, UIUtils.Label) tuple = UIUtils.MakeButtonWithImage("Prefab Editor", _mapUI, Vector2.op_Implicit(new Vector3(-25f, -45f)), new Vector2(1f, 1f), new Vector2(1f, 1f), 96, 48);
			Button item = tuple.Item1;
			Image item2 = tuple.Item2;
			GameObject val = new GameObject("Open Prefab");
			val.transform.parent = _mapUI.transform;
			GameObject openPrefab = val;
			RectTransform val2 = openPrefab.AddComponent<RectTransform>();
			val2.anchorMax = Vector2.one;
			val2.anchorMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			val2.offsetMin = Vector2.zero;
			openPrefab.SetActive(false);
			InputField textbox = UIUtils.MakeTextbox("Name", openPrefab, new Vector2(0f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 300f, 30f).Item1;
			UIUtils.Label label = UIUtils.MakeLabel("Prompt", openPrefab, new Vector2(0f, 20f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1);
			((Text)label.textComponent).fontSize = 12;
			((Text)label.textComponent).text = "Enter Prefab Name:";
			((Text)label.textComponent).alignment = (TextAnchor)4;
			((UnityEvent)UIUtils.MakeTextButton("Cancel", "Cancel", openPrefab, new Vector2(-25f, -20f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(100f, 30f)).Item1.onClick).AddListener((UnityAction)delegate
			{
				openPrefab.SetActive(false);
			});
			((UnityEvent)UIUtils.MakeTextButton("Confirm", "Confirm", openPrefab, new Vector2(25f, -20f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(100f, 30f)).Item1.onClick).AddListener((UnityAction)delegate
			{
				if (textbox.text.Length != 0)
				{
					openPrefab.SetActive(false);
					PrefabManager.Toggle(textbox.text);
				}
			});
			Image val3 = UIUtils.MakeImage("Background", openPrefab, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(400f, 300f));
			val3.sprite = UIUtils.Square;
			((Graphic)val3).color = new Color(0.2f, 0.2f, 0.2f);
			((Component)val3).transform.SetAsFirstSibling();
			((UnityEvent)item.onClick).AddListener((UnityAction)delegate
			{
				if ((Input.GetKey((KeyCode)308) && PrefabManager.Last != null) || PrefabManager.InPrefabScene)
				{
					openPrefab.SetActive(false);
					PrefabManager.Toggle(PrefabManager.Last);
				}
				else
				{
					textbox.text = "";
					openPrefab.SetActive(true);
				}
			});
			item2.sprite = PrefabManager.PrefabIcon;
			Button item3 = UIUtils.MakeTextButton("Prefabs", "Prefabs", _mapUI, new Vector2(-25f, -70f), new Vector2(1f, 1f), new Vector2(1f, 1f)).Item1;
			ButtonClickedEvent onClick = item3.onClick;
			object obj = <>c.<>9__43_3;
			if (obj == null)
			{
				UnityAction val4 = delegate
				{
					PageIndex = 0;
					CurrentCategory = PrefabsCategory.Instance;
					DoRefreshCurrentPage();
				};
				<>c.<>9__43_3 = val4;
				obj = (object)val4;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
		}

		private static void MakeToolButton(ToolObject obj, int xShift, int yShift)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 0f);
			var (val2, val3, _) = UIUtils.MakeButtonWithImage(obj.GetName(), _mapUI, Vector2.op_Implicit(new Vector3((float)(-25 - xShift), (float)(25 + yShift))), val, val, 96, 48);
			((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
			{
				SetItem(obj.Index);
			});
			val3.sprite = obj.GetUISprite();
		}

		public static void RefreshVisibility(bool editing, bool paused)
		{
			_canvasObj.SetActive(editing);
			if (!editing)
			{
				return;
			}
			RefreshCurrentTab(paused);
			foreach (GameObject item in DisableWhenPlaying)
			{
				item.SetActive(paused);
			}
			foreach (GameObject item2 in EnableWhenPlaying)
			{
				item2.SetActive(!paused);
			}
			if (paused)
			{
				SetupLegacy(Settings.LegacyEventSystem.Value);
				ScriptEditorUI.UpdateColour();
			}
			else
			{
				_mapUI.SetActive(false);
				_scriptUI.SetActive(false);
				_workshopUI.SetActive(false);
				Deletable.DeleteButton.SetActive(false);
				_currentType = EditorType.Map;
			}
			bool active = paused && CoopManager.Instance.IsActive();
			_shareLevelButton.SetActive(active);
			_shareLevelLabel.SetActive(active);
			_shareScriptButton.SetActive(active);
			_shareScriptLabel.SetActive(active);
		}

		private static void SetupLegacy(bool legacy)
		{
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			((Component)_legacyCategory.Item2).gameObject.SetActive(legacy);
			((Component)_legacyCategory.Item1).gameObject.SetActive(legacy);
			((Component)_configButton.Item1).gameObject.SetActive(legacy);
			((Component)_configButton.Item2).gameObject.SetActive(legacy);
			((Component)_broadcastersButton.Item1).gameObject.SetActive(legacy);
			((Component)_broadcastersButton.Item2).gameObject.SetActive(legacy);
			((Component)_receiversButton.Item1).gameObject.SetActive(legacy);
			((Component)_receiversButton.Item2).gameObject.SetActive(legacy);
			((Component)_mapButton.Item1).gameObject.SetActive(!legacy);
			((Component)_mapButton.Item2).gameObject.SetActive(!legacy);
			((Component)_scriptButton.Item1).gameObject.SetActive(!legacy);
			((Component)_scriptButton.Item2).gameObject.SetActive(!legacy);
			((Component)_workshopButton.Item1).gameObject.SetActive(!legacy);
			((Component)_workshopButton.Item2).gameObject.SetActive(!legacy);
			if (Object.op_Implicit((Object)(object)_configTransform))
			{
				_configTransform.anchoredPosition = new Vector2(0f, (float)((!legacy) ? (-20) : 0));
			}
			_mapTransform.anchoredPosition = new Vector2(0f, (float)((!legacy) ? 20 : 0));
			if (legacy)
			{
				_currentType = EditorType.Map;
				UIManager.instance.uiState = (UIState)5;
				Deletable.DeleteButton.SetActive(false);
			}
			else
			{
				_currentOption = AttributeType.Config;
				if (CurrentCategory == Categories.Legacy)
				{
					PageIndex = 0;
					CurrentCategory = Categories.All;
					DoRefreshCurrentPage();
				}
			}
			_mapUI.SetActive(_currentType == EditorType.Map);
			_scriptUI.SetActive(_currentType == EditorType.Script);
			_workshopUI.SetActive(_currentType == EditorType.Workshop);
		}

		public static void WipeTabs()
		{
			Object.Destroy((Object)(object)_configTab);
			Object.Destroy((Object)(object)_receiverTab);
			Object.Destroy((Object)(object)_broadcasterTab);
		}

		public static void SetItem(int i)
		{
			int num = PageIndex * 9 + i;
			if (_categoryContents.Count <= num)
			{
				i = -99;
			}
			EditManager.TryFindEmptySlot();
			EditManager.ClearAttributes();
			EditManager.CurrentlyFlipped = false;
			EditManager.SetRotation(0f);
			EditManager.SetScale(1f);
			CursorManager.ObjectChanged = true;
			bool flag = false;
			if (i < 0)
			{
				if (1 == 0)
				{
				}
				SelectableObject currentObject = i switch
				{
					-1 => CursorObject.Instance, 
					-2 => EraserObject.Instance, 
					-3 => PickObject.Instance, 
					-4 => DragObject.Instance, 
					-5 => ResetObject.Instance, 
					-6 => TileChangerObject.Instance, 
					-7 => LockObject.Instance, 
					_ => BlankObject.Instance, 
				};
				if (1 == 0)
				{
				}
				EditManager.CurrentObject = currentObject;
			}
			else
			{
				SelectableObject selectableObject = _categoryContents[num];
				SelectableObject selectableObject2 = selectableObject;
				SelectableObject selectableObject3 = selectableObject2;
				if (selectableObject3 is PreloadObject preloadObject)
				{
					if (!preloadObject.Loaded)
					{
						return;
					}
				}
				else if (selectableObject3 is SavedObject savedObject)
				{
					selectableObject = savedObject.PlaceableObject;
					EditManager.Broadcasters.AddRange(savedObject.Placement.Broadcasters);
					EditManager.Receivers.AddRange(savedObject.Placement.Receivers);
					Architect.Config.Types.ConfigValue[] config = savedObject.Placement.Config;
					foreach (Architect.Config.Types.ConfigValue configValue in config)
					{
						EditManager.Config[configValue.GetTypeId()] = configValue;
					}
					EditManager.SetScale(savedObject.Placement.GetScale());
					EditManager.SetRotation(savedObject.Placement.GetRotation());
					EditManager.CurrentlyFlipped = savedObject.Placement.IsFlipped();
					flag = true;
				}
				EditManager.CurrentObject = selectableObject;
			}
			WipeTabs();
			RefreshAttributeControls(!flag);
			RefreshItem();
		}

		public static void RefreshAttributeControls(bool useDefaultConfig)
		{
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			if (EditManager.CurrentObject is PlaceableObject placeableObject)
			{
				if (useDefaultConfig)
				{
					foreach (Architect.Config.Types.ConfigValue item in from configType in placeableObject.ConfigGroup
						select configType.GetDefaultValue() into val
						where val != null
						select val)
					{
						EditManager.Config[item.GetTypeId()] = item;
					}
				}
				_currentOption = AttributeType.Config;
				flag = placeableObject.ConfigGroup.Count > 0;
				if (flag)
				{
					SetupConfigTab(placeableObject.ConfigGroup);
				}
				flag2 = placeableObject.ReceiverGroup.Count > 0;
				if (flag2)
				{
					SetupReceiverTab(placeableObject.ReceiverGroup);
				}
				flag3 = placeableObject.BroadcasterGroup.Count > 0;
				if (flag3)
				{
					SetupBroadcasterTab(placeableObject.BroadcasterGroup);
				}
			}
			((Selectable)_configButton.Item1).interactable = flag;
			((Selectable)_receiversButton.Item1).interactable = flag2;
			((Selectable)_broadcastersButton.Item1).interactable = flag3;
		}

		private static void SetupConfigTab(List<Architect.Config.Types.ConfigType> group)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Expected O, but got Unknown
			(_configTab, _configTransform) = PrepareTab("Config Tab");
			ConfigIds.Clear();
			((Component)_configButton.Item1).transform.SetAsLastSibling();
			int num = 20 + 14 * group.Count;
			foreach (Architect.Config.Types.ConfigType item in group)
			{
				Architect.Config.Types.ConfigType type = item;
				UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Config Title", _configTab, Vector2.op_Implicit(new Vector3(54f, (float)num)), Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1).textComponent;
				((Text)textComponent).text = type.Name;
				((Text)textComponent).fontSize = 8;
				((Text)textComponent).alignment = (TextAnchor)3;
				var (btn, _) = UIUtils.MakeTextButton("Config Apply", "Apply", _configTab, Vector2.op_Implicit(new Vector3(262f, (float)num)), Vector2.zero, Vector2.zero);
				((Selectable)btn).interactable = false;
				Architect.Config.Types.ConfigElement inp = type.CreateInput(_configTab, btn, new Vector3(142f, (float)num), EditManager.Config.GetValueOrDefault(type.Id)?.SerializeValue());
				if (inp is Architect.Config.Types.IdConfigElement idConfigElement)
				{
					ConfigIds.Add((idConfigElement.GetField(), Apply));
				}
				((UnityEvent)btn.onClick).AddListener(new UnityAction(Apply));
				num -= 14;
				void Apply()
				{
					((Selectable)btn).interactable = false;
					string value = inp.GetValue();
					if (value.Length == 0)
					{
						EditManager.Config.Remove(type.Id);
					}
					else
					{
						EditManager.Config[type.Id] = type.Deserialize(inp.GetValue());
					}
					CursorManager.ObjectChanged = true;
				}
			}
		}

		private static void SetupReceiverTab(List<EventReceiverType> group)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			_receiverTab = PrepareTab("Receiver Tab").Item1;
			_receiverCount = 0;
			((Component)_receiversButton.Item1).transform.SetAsLastSibling();
			MakeEventTabLabel(_receiverTab, "Name", new Vector3(50f, 235f));
			MakeEventTabLabel(_receiverTab, "Trigger", new Vector3(142f, 235f));
			MakeEventTabLabel(_receiverTab, "Times", new Vector3(204f, 235f));
			MakeEventTabLabel(_receiverTab, "Add/Remove", new Vector3(252f, 235f));
			InputField eventInput = UIUtils.MakeTextbox("Receiver Event Input", _receiverTab, Vector2.op_Implicit(new Vector3(50f, 220f)), Vector2.zero, Vector2.zero, 200f, 25f).Item1;
			int currentTriggerIndex = 0;
			(Button, UIUtils.Label) tuple = UIUtils.MakeTextButton("Receiver Trigger Choice", group[currentTriggerIndex].Name, _receiverTab, Vector2.op_Implicit(new Vector3(142f, 220f)), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(200f, 25f));
			Button item = tuple.Item1;
			UIUtils.Label btnLabel = tuple.Item2;
			ChoiceButton choiceButton = ((Component)item).gameObject.AddComponent<ChoiceButton>();
			choiceButton.OnLeftClick = (Action)Delegate.Combine(choiceButton.OnLeftClick, (Action)delegate
			{
				currentTriggerIndex = (currentTriggerIndex + 1) % group.Count;
				((Text)btnLabel.textComponent).text = group[currentTriggerIndex].Name;
			});
			choiceButton.OnRightClick = (Action)Delegate.Combine(choiceButton.OnRightClick, (Action)delegate
			{
				currentTriggerIndex = (currentTriggerIndex - 1) % group.Count;
				if (currentTriggerIndex < 0)
				{
					currentTriggerIndex += group.Count;
				}
				((Text)btnLabel.textComponent).text = group[currentTriggerIndex].Name;
			});
			var (timesField, _) = UIUtils.MakeTextbox("Receiver Times", _receiverTab, Vector2.op_Implicit(new Vector3(204f, 220f)), Vector2.zero, Vector2.zero, 80f, 25f);
			timesField.characterValidation = (CharacterValidation)1;
			timesField.text = "1";
			var (addBtn, _) = UIUtils.MakeTextButton("Receiver Add", "+", _receiverTab, Vector2.op_Implicit(new Vector3(252f, 220f)), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(30f, 30f));
			((Selectable)addBtn).interactable = false;
			((UnityEvent<string>)(object)eventInput.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				((Selectable)addBtn).interactable = s.Length > 0;
			});
			((UnityEvent)addBtn.onClick).AddListener((UnityAction)delegate
			{
				string text = timesField.text;
				int item2 = ((text.Length == 0) ? 1 : Convert.ToInt32(text));
				(string, string, int) tuple4 = (eventInput.text, group[currentTriggerIndex].Id, item2);
				eventInput.text = "";
				((Selectable)addBtn).interactable = false;
				AddReceiverToTab(tuple4, group[currentTriggerIndex].Name);
				EditManager.Receivers.Add(tuple4);
			});
			foreach (var receiver in EditManager.Receivers)
			{
				AddReceiverToTab(receiver, EventManager.GetReceiverType(receiver.Item2).Name);
			}
		}

		private static void AddReceiverToTab((string, string, int) data, string name)
		{
			//IL_0035: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			int num = 207 - 12 * _receiverCount;
			GameObject r1 = MakeEventTabLabel(_receiverTab, data.Item1, new Vector3(50f, (float)num));
			GameObject r2 = MakeEventTabLabel(_receiverTab, name, new Vector3(142f, (float)num));
			GameObject r3 = MakeEventTabLabel(_receiverTab, data.Item3.ToString(), new Vector3(204f, (float)num));
			var (addBtn, btnLabel) = UIUtils.MakeTextButton("Receiver Remove", "-", _receiverTab, Vector2.op_Implicit(new Vector3(252f, (float)num)), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(30f, 30f));
			((UnityEvent)addBtn.onClick).AddListener((UnityAction)delegate
			{
				Object.Destroy((Object)(object)r1);
				Object.Destroy((Object)(object)r2);
				Object.Destroy((Object)(object)r3);
				Object.Destroy((Object)(object)((Component)addBtn).gameObject);
				Object.Destroy((Object)(object)((Component)btnLabel).gameObject);
				EditManager.Receivers.Remove(data);
			});
			_receiverCount++;
		}

		private static void SetupBroadcasterTab(List<string> group)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_016c: 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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			_broadcasterTab = PrepareTab("Broadcaster Tab").Item1;
			_broadcasterCount = 0;
			((Component)_broadcastersButton.Item1).transform.SetAsLastSibling();
			MakeEventTabLabel(_broadcasterTab, "Event", new Vector3(50f, 235f));
			MakeEventTabLabel(_broadcasterTab, "Name", new Vector3(142f, 235f));
			MakeEventTabLabel(_broadcasterTab, "Add/Remove", new Vector3(228f, 235f));
			int currentTriggerIndex = 0;
			(Button, UIUtils.Label) tuple = UIUtils.MakeTextButton("Broadcaster Cause Choice", group[currentTriggerIndex], _broadcasterTab, Vector2.op_Implicit(new Vector3(50f, 220f)), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(200f, 25f));
			Button item = tuple.Item1;
			UIUtils.Label btnLabel = tuple.Item2;
			ChoiceButton choiceButton = ((Component)item).gameObject.AddComponent<ChoiceButton>();
			choiceButton.OnLeftClick = (Action)Delegate.Combine(choiceButton.OnLeftClick, (Action)delegate
			{
				currentTriggerIndex = (currentTriggerIndex + 1) % group.Count;
				((Text)btnLabel.textComponent).text = group[currentTriggerIndex];
			});
			choiceButton.OnRightClick = (Action)Delegate.Combine(choiceButton.OnRightClick, (Action)delegate
			{
				currentTriggerIndex = (currentTriggerIndex - 1) % group.Count;
				if (currentTriggerIndex < 0)
				{
					currentTriggerIndex += group.Count;
				}
				((Text)btnLabel.textComponent).text = group[currentTriggerIndex];
			});
			var (eventInput, _) = UIUtils.MakeTextbox("Broadcaster Event Input", _broadcasterTab, Vector2.op_Implicit(new Vector3(142f, 220f)), Vector2.zero, Vector2.zero, 200f, 25f);
			var (addBtn, _) = UIUtils.MakeTextButton("Broadcaster Add", "+", _broadcasterTab, Vector2.op_Implicit(new Vector3(228f, 220f)), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(30f, 30f));
			((Selectable)addBtn).interactable = false;
			((UnityEvent<string>)(object)eventInput.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				((Selectable)addBtn).interactable = s.Length > 0;
			});
			((UnityEvent)addBtn.onClick).AddListener((UnityAction)delegate
			{
				(string, string) tuple4 = (group[currentTriggerIndex], eventInput.text);
				eventInput.text = "";
				((Selectable)addBtn).interactable = false;
				AddBroadcasterToTab(tuple4);
				EditManager.Broadcasters.Add(tuple4);
			});
			foreach (var broadcaster in EditManager.Broadcasters)
			{
				AddBroadcasterToTab(broadcaster);
			}
		}

		private static void AddBroadcasterToTab((string, string) data)
		{
			//IL_0035: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			int num = 207 - 12 * _broadcasterCount;
			GameObject r2 = MakeEventTabLabel(_broadcasterTab, data.Item1, new Vector3(50f, (float)num));
			GameObject r1 = MakeEventTabLabel(_broadcasterTab, data.Item2, new Vector3(142f, (float)num));
			var (addBtn, btnLabel) = UIUtils.MakeTextButton("Broadcaster Remove", "-", _broadcasterTab, Vector2.op_Implicit(new Vector3(228f, (float)num)), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(30f, 30f));
			((UnityEvent)addBtn.onClick).AddListener((UnityAction)delegate
			{
				Object.Destroy((Object)(object)r1);
				Object.Destroy((Object)(object)r2);
				Object.Destroy((Object)(object)((Component)addBtn).gameObject);
				Object.Destroy((Object)(object)((Component)btnLabel).gameObject);
				EditManager.Broadcasters.Remove(data);
			});
			_broadcasterCount++;
		}

		private static GameObject MakeEventTabLabel(GameObject tab, string text, Vector3 pos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			UIUtils.Label label = UIUtils.MakeLabel(text, tab, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1);
			((Text)label.textComponent).text = text;
			((Text)label.textComponent).fontSize = 8;
			((Text)label.textComponent).alignment = (TextAnchor)4;
			((Component)label).transform.SetAsFirstSibling();
			return ((Component)label).gameObject;
		}

		private static (GameObject, RectTransform) PrepareTab(string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.SetActive(false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.zero;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			((Transform)val2).SetParent(_mapUI.transform, false);
			((Transform)val2).SetAsLastSibling();
			return (val, val2);
		}

		private static void RefreshCurrentTab(bool paused)
		{
			if (Object.op_Implicit((Object)(object)_configTab))
			{
				_configTab.SetActive(paused && _currentOption == AttributeType.Config);
			}
			if (Object.op_Implicit((Object)(object)_broadcasterTab))
			{
				_broadcasterTab.SetActive(paused && _currentOption == AttributeType.Events);
			}
			if (Object.op_Implicit((Object)(object)_receiverTab))
			{
				_receiverTab.SetActive(paused && _currentOption == AttributeType.Listeners);
			}
		}

		private static void ToggleFavourite(int i, UIUtils.Label label)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			int num = PageIndex * 9 + i;
			if (_categoryContents.Count <= num)
			{
				return;
			}
			SelectableObject selectableObject = _categoryContents[num];
			SelectableObject selectableObject2 = selectableObject;
			if (selectableObject2 is PrefabObject)
			{
				return;
			}
			if (!(selectableObject2 is PlaceableObject obj))
			{
				if (selectableObject2 is SavedObject saved)
				{
					SavedCategory.RemovePrefab(saved);
					DoRefreshCurrentPage();
				}
			}
			else if (FavouritesCategory.ToggleFavourite(obj))
			{
				((Text)label.textComponent).text = "★";
				((Graphic)label.textComponent).color = Color.yellow;
			}
			else
			{
				((Text)label.textComponent).text = "☆";
				((Graphic)label.textComponent).color = Color.white;
			}
		}

		public static void RefreshItem()
		{
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected I4, but got Unknown
			Image icon = HotbarIcons[EditManager.HotbarIndex];
			icon.sprite = EditManager.CurrentObject.GetUISprite();
			Architect.Config.Types.ConfigValue configValue = EditManager.Config.Values.FirstOrDefault((Architect.Config.Types.ConfigValue c) => c.GetTypeId() == "png_url");
			if (configValue != null)
			{
				CustomAssetManager.DoLoadSprite(configValue.SerializeValue(), point: true, 100f, 1, 1, delegate(Sprite[] sprites)
				{
					icon.sprite = sprites[0];
				});
			}
			float num = 0f;
			Extensions.SetScaleX(((Component)icon).transform, 1.25f);
			Extensions.SetScaleY(((Component)icon).transform, 1.25f);
			if (EditManager.CurrentObject is PlaceableObject placeableObject)
			{
				SpritePackingRotation packingRotation = placeableObject.GetUISprite().packingRotation;
				SpritePackingRotation val = packingRotation;
				switch (val - 1)
				{
				case 0:
					Extensions.SetScaleX(((Component)icon).transform, -1.25f);
					break;
				case 1:
					Extensions.SetScaleY(((Component)icon).transform, -1.25f);
					break;
				case 2:
					num += 180f;
					break;
				}
				num += placeableObject.Rotation + placeableObject.ChildRotation + (float)placeableObject.Tk2dRotation;
			}
			else
			{
				Extensions.SetScale2D(((Component)icon).transform, new Vector2(1f, 1f));
			}
			Extensions.SetRotationZ(((Component)icon).transform, num);
			((Text)_currentlySelected.textComponent).text = EditManager.CurrentObject.GetName();
			((Text)_currentlySelectedDesc.textComponent).text = EditManager.CurrentObject.GetDescription();
			((Behaviour)ScaleText).enabled = !(EditManager.CurrentObject?.DisableTransformations ?? true);
			((Behaviour)RotationText).enabled = !(EditManager.CurrentObject?.DisableTransformations ?? true);
		}

		public static void DoRefreshCurrentPage()
		{
			_refreshRoutineId++;
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(RefreshCurrentPage(_refreshRoutineId));
		}

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

		public static void Shift(int amount)
		{
			PageIndex += amount;
			if (_categoryContents != null)
			{
				int num = (_categoryContents.Count - 1) / 9;
				if (PageIndex > num)
				{
					PageIndex = 0;
				}
				else if (PageIndex < 0)
				{
					PageIndex = num;
				}
				DoRefreshCurrentPage();
			}
		}

		private static void SetupSearchBox()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(-65f, 131.25f);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(1f, 0f);
			InputField item = UIUtils.MakeTextbox("Search Box", _mapUI, Vector2.op_Implicit(val), val2, val2, 300f, 32f).Item1;
			((UnityEvent<string>)(object)item.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				PageIndex = 0;
				_currentSearch = s;
				DoRefreshCurrentPage();
			});
			UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Search Box Placeholder", _mapUI, Vector2.op_Implicit(val), val2, val2, 280f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent).text = "Search...";
			Transform transform = ((Component)textComponent).transform;
			transform.localScale /= 3f;
			((Text)textComponent).fontSize = 20;
			((Text)textComponent).alignment = (TextAnchor)3;
			((Graphic)textComponent).color = Color.grey;
			((Text)textComponent).fontStyle = (FontStyle)2;
			item.placeholder = (Graphic)(object)textComponent;
		}

		private static void SetupPreciseSettings()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 0f);
			RotationText = UIUtils.MakeTextbox("Rotation Box", _mapUI, Vector2.op_Implicit(new Vector3(-65f, 170f)), val, val, 70f, 32f).Item1;
			RotationText.characterValidation = (CharacterValidation)2;
			((UnityEvent<string>)(object)RotationText.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				try
				{
					EditManager.CurrentRotation = Convert.ToSingle(s, CultureInfo.InvariantCulture);
				}
				catch (FormatException)
				{
					EditManager.SetRotation(0f);
				}
				CursorManager.NeedsRefresh = true;
			});
			ScaleText = UIUtils.MakeTextbox("Scale Box", _mapUI, Vector2.op_Implicit(new Vector3(-65f, 190f)), val, val, 70f, 32f).Item1;
			ScaleText.characterValidation = (CharacterValidation)2;
			((UnityEvent<string>)(object)ScaleText.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				try
				{
					EditManager.CurrentScale = Convert.ToSingle(s, CultureInfo.InvariantCulture);
				}
				catch (FormatException)
				{
					EditManager.SetScale(1f);
				}
				CursorManager.NeedsRefresh = true;
			});
			UIUtils.Label label = UIUtils.MakeLabel("Rotation Label", _mapUI, Vector2.op_Implicit(new Vector3(-75f, 170f)), val, val, 80f, 80f, (HorizontalWrapMode)1);
			((Text)label.textComponent).text = "Rotation: ";
			((Text)label.textComponent).fontSize = 8;
			((Text)label.textComponent).alignment = (TextAnchor)3;
			UIUtils.Label label2 = UIUtils.MakeLabel("Scale Label", _mapUI, Vector2.op_Implicit(new Vector3(-75f, 190f)), val, val, 80f, 80f, (HorizontalWrapMode)1);
			((Text)label2.textComponent).text = "Scale: ";
			((Text)label2.textComponent).fontSize = 8;
			((Text)label2.textComponent).alignment = (TextAnchor)3;
			EditManager.SetRotation(0f);
			EditManager.SetScale(1f);
		}

		private static void SetupAttributeSettings()
		{
			//IL_0018: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 pos = default(Vector3);
			((Vector3)(ref pos))..ctor(50f, 13.25f);
			_configButton = SetupAttributeButton(AttributeType.Config, "Config", pos);
			pos.x += 92f;
			_broadcastersButton = SetupAttributeButton(AttributeType.Events, "Events", pos);
			pos.x += 92f;
			_receiversButton = SetupAttributeButton(AttributeType.Listeners, "Listeners", pos);
		}

		private static (Button, UIUtils.Label) SetupAttributeButton(AttributeType type, string name, Vector3 pos)
		{
			//IL_0030: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			Vector2 size = default(Vector2);
			((Vector2)(ref size))..ctor(260f, 30f);
			var (val, item) = UIUtils.MakeTextButton(name + " Button", name, _mapUI, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, hasOutline: true, size);
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				_currentOption = type;
			});
			((Selectable)val).interactable = false;
			return (val, item);
		}

		private static void SetupHotbar()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			for (int i = -4; i < 5; i++)
			{
				var (val, val2, label) = UIUtils.MakeButtonWithImage("Hotbar Part", _canvasObj, Vector2.op_Implicit(new Vector3((float)(i * 45), 35f)), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), 96, 48);
				((Behaviour)val).enabled = false;
				val2.sprite = ArchitectPlugin.BlankSprite;
				HotbarIcons.Add(val2);
				EnableWhenPlaying.Add(((Component)val).gameObject);
				EnableWhenPlaying.Add(((Component)val2).gameObject);
				EnableWhenPlaying.Add(((Component)label).gameObject);
			}
		}

		private static void SetupLayers()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Expected O, but got Unknown
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Expected O, but got Unknown
			GameObject val = new GameObject("Layers");
			val.transform.parent = _mapUI.transform;
			GameObject val2 = val;
			val2.RemoveOffset().anchoredPosition = new Vector2(0f, -20f);
			LayerName = (Text)(object)UIUtils.MakeLabel("Layer Name", val2, new Vector2(0f, 45f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			LayerName.fontSize = 14;
			LayerName.text = $"Layer\n{EditManager.Layer}";
			LayerName.alignment = (TextAnchor)4;
			var (val3, label) = UIUtils.MakeTextButton("Show All", "Show All", val2, new Vector2(75f, 55f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(120f, 35f));
			((Text)label.textComponent).fontSize = 10;
			var (val4, label2) = UIUtils.MakeTextButton("Hide All", "Hide All", val2, new Vector2(75f, 35f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(120f, 35f));
			((Text)label2.textComponent).fontSize = 10;
			ButtonClickedEvent onClick = val3.onClick;
			object obj = <>c.<>9__79_0;
			if (obj == null)
			{
				UnityAction val5 = delegate
				{
					EditManager.ShowLayersByDefault = true;
					EditManager.FlippedLayers.Clear();
					EditManager.Layer = EditManager.Layer;
				};
				<>c.<>9__79_0 = val5;
				obj = (object)val5;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = val4.onClick;
			object obj2 = <>c.<>9__79_1;
			if (obj2 == null)
			{
				UnityAction val6 = delegate
				{
					EditManager.ShowLayersByDefault = false;
					EditManager.FlippedLayers.Clear();
					EditManager.Layer = EditManager.Layer;
				};
				<>c.<>9__79_1 = val6;
				obj2 = (object)val6;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Visible Label", val2, new Vector2(-75f, 52.5f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)textComponent).fontSize = 10;
			((Text)textComponent).text = "Always Show";
			((Text)textComponent).alignment = (TextAnchor)4;
			(Button, UIUtils.Label) tuple3 = UIUtils.MakeTextButton("Visible", "X", val2, new Vector2(-75f, 35f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(35f, 35f));
			Button item = tuple3.Item1;
			UIUtils.Label item2 = tuple3.Item2;
			ButtonClickedEvent onClick3 = item.onClick;
			object obj3 = <>c.<>9__79_2;
			if (obj3 == null)
			{
				UnityAction val7 = delegate
				{
					if (!EditManager.FlippedLayers.Remove(EditManager.Layer))
					{
						EditManager.FlippedLayers.Add(EditManager.Layer);
					}
					EditManager.Layer = EditManager.Layer;
				};
				<>c.<>9__79_2 = val7;
				obj3 = (object)val7;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			LayerToggle = (Text)(object)item2.textComponent;
			LayerToggle.fontSize = 10;
			var (val8, label3) = UIUtils.MakeTextButton("Left", "<", val2, new Vector2(-35f, 45f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(35f, 35f));
			((Text)label3.textComponent).fontSize = 10;
			ButtonClickedEvent onClick4 = val8.onClick;
			object obj4 = <>c.<>9__79_3;
			if (obj4 == null)
			{
				UnityAction val9 = delegate
				{
					EditManager.Layer = Math.Max(0, EditManager.Layer - 1);
				};
				<>c.<>9__79_3 = val9;
				obj4 = (object)val9;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			var (val10, label4) = UIUtils.MakeTextButton("Right", ">", val2, new Vector2(35f, 45f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(35f, 35f));
			((Text)label4.textComponent).fontSize = 10;
			ButtonClickedEvent onClick5 = val10.onClick;
			object obj5 = <>c.<>9__79_4;
			if (obj5 == null)
			{
				UnityAction val11 = delegate
				{
					EditManager.Layer++;
				};
				<>c.<>9__79_4 = val11;
				obj5 = (object)val11;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
			DisableWhenPlaying.Add(val2);
		}
	}
	public class GroupSelectionBox : MonoBehaviour
	{
		public float width = 1f;

		public float height = 1f;

		public float lineThickness = 0.06f;

		private LineRenderer _lineRenderer;

		private void Start()
		{
			_lineRenderer = ((Component)this).GetComponent<LineRenderer>();
			_lineRenderer.positionCount = 4;
			_lineRenderer.loop = true;
			_lineRenderer.useWorldSpace = false;
			_lineRenderer.widthMultiplier = lineThickness;
		}

		public void UpdateOutline()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			Vector3[] positions = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(0f, 0f, 0f),
				new Vector3(width, 0f, 0f),
				new Vector3(width, height, 0f),
				new Vector3(0f, height, 0f)
			};
			LineRenderer lineRenderer = _lineRenderer;
			if (lineRenderer != null)
			{
				lineRenderer.SetPositions(positions);
			}
		}
	}
	public static class RespawnMarkerManager
	{
		public class RespawnPreview : MonoBehaviour
		{
			private PlayerData _pd;

			private Vector3 _lastPos;

			private bool _lastLeft;

			private bool _showPoint;

			private void Start()
			{
				_pd = PlayerData.instance;
			}

			private void Update()
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: 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_005f: Invalid comparison between Unknown and I4
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: 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)
				bool value = Settings.ShowRespawnPoint.Value;
				if (value != _showPoint)
				{
					_marker.SetActive(value);
					_showPoint = value;
				}
				if (!_showPoint)
				{
					return;
				}
				FacingDirection hazardRespawnFacing = _pd.hazardRespawnFacing;
				if (1 == 0)
				{
				}
				bool flag = (((int)hazardRespawnFacing == 0) ? (_pd.hazardRespawnLocation.x - HeroController.instance.transform.position.x > 0.1f) : ((int)hazardRespawnFacing == 1));
				if (1 == 0)
				{
				}
				bool flag2 = flag;
				if (flag2 != _lastLeft || !(_pd.hazardRespawnLocation == _lastPos))
				{
					_lastLeft = flag2;
					_lastPos = _pd.hazardRespawnLocation;
					Vector2 val = default(Vector2);
					if (HeroController.instance.TryFindGroundPoint(ref val, Vector2.op_Implicit(_lastPos), false))
					{
						Extensions.SetPositionX(_marker.transform, val.x);
						Extensions.SetPositionY(_marker.transform, val.y - 0.15f);
						Extensions.SetScaleX(_icon.transform, (float)(flag2 ? 1 : (-1)));
					}
				}
			}

			private void OnDisable()
			{
				if (Object.op_Implicit((Object)(object)_marker))
				{
					_marker.SetActive(false);
				}
			}
		}

		private static GameObject _marker;

		private static GameObject _icon;

		public static void Init()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_008f: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("[Architect] Respawn Marker");
			val.transform.position = new Vector3(0f, 0f, 0.005f);
			_marker = val;
			_marker.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_marker);
			GameObject val2 = new GameObject("Icon");
			val2.transform.parent = _marker.transform;
			val2.transform.localPosition = Vector3.zero;
			_icon = val2;
			_marker.AddComponent<SpriteRenderer>().sprite = ResourceUtils.LoadSpriteResource("respawn_text", (FilterMode)1, default(Vector4), 64f);
			_icon.AddComponent<SpriteRenderer>().sprite = ResourceUtils.LoadSpriteResource("respawn_marker", (FilterMode)1, default(Vector4), 64f);
			typeof(HeroController).Hook("Awake", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				((Component)self).gameObject.AddComponent<RespawnPreview>();
			});
		}
	}
	public static class ScriptEditorUI
	{
		public class BackgroundDrag : MonoBehaviour, IDragHandler, IEventSystemHandler, IBeginDragHandler, IPointerDownHandler, IPointerUpHandler
		{
			private Vector2 _offset;

			private Image _selectionImage;

			private RectTransform _selectionRect;

			private RectTransform _uiParentRect;

			private Vector2 _selectStartLocal;

			private Vector2 _selectStartScreen;

			private bool _isSelecting;

			private void Awake()
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				ref RectTransform uiParentRect = ref _uiParentRect;
				Transform parent = ((Component)this).transform.parent;
				uiParentRect = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				GameObject val = new GameObject("Selection Rectangle");
				val.transform.SetParent((Transform)(object)_uiParentRect, false);
				_selectionRect = val.AddComponent<RectTransform>();
				_selectionRect.anchorMin = Vector2.zero;
				_selectionRect.anchorMax = Vector2.zero;
				_selectionRect.pivot = Vector2.zero;
				_selectionRect.anchoredPosition = Vector2.zero;
				_selectionRect.sizeDelta = Vector2.zero;
				((Transform)_selectionRect).localScale = Vector3.one;
				_selectionImage = val.AddComponent<Image>();
				_selectionImage.sprite = UIUtils.Square;
				((Graphic)_selectionImage).color = Settings.ScriptEditorSelectionColor.Value;
				((Graphic)_selectionImage).raycastTarget = false;
				Outline val2 = val.AddComponent<Outline>();
				((Shadow)val2).effectColor = Settings.ScriptEditorSelectionOutlineColor.Value;
				((Shadow)val2).effectDistance = new Vector2(1.5f, 1.5f);
				((Shadow)val2).useGraphicAlpha = true;
				val.transform.SetAsLastSibling();
				val.SetActive(false);
			}

			public void OnPointerDown(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Invalid comparison between Unknown and I4
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: 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_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				if ((int)eventData.button == 0)
				{
					ScriptManager.ClearSelection();
				}
				else if ((int)eventData.button == 1 && Object.op_Implicit((Object)(object)_uiParentRect))
				{
					_selectStartScreen = eventData.position;
					if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(_uiParentRect, eventData.position, eventData.pressEventCamera, ref _selectStartLocal))
					{
						_isSelecting = false;
						return;
					}
					_isSelecting = true;
					Rect rect = _uiParentRect.rect;
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(((Rect)(ref rect)).width * _uiParentRect.pivot.x, ((Rect)(ref rect)).height * _uiParentRect.pivot.y);
					Vector2 anchoredPosition = _selectStartLocal + val;
					_selectionRect.anchoredPosition = anchoredPosition;
					_selectionRect.sizeDelta = Vector2.zero;
					((Component)_selectionImage).gameObject.SetActive(true);
					((Component)_selectionRect).transform.SetAsLastSibling();
				}
			}

			public void OnBeginDrag(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if ((int)eventData.button == 0)
				{
					_offset = Vector2.op_Implicit(ScriptParent.transform.position) - eventData.position;
				}
			}

			public void OnDrag(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected I4, but got Unknown
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: 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_006e: 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_0096: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				InputButton button = eventData.button;
				InputButton val = button;
				switch ((int)val)
				{
				case 1:
				{
					Vector2 val2 = default(Vector2);
					if (_isSelecting && Object.op_Implicit((Object)(object)_uiParentRect) && RectTransformUtility.ScreenPointToLocalPointInRectangle(_uiParentRect, eventData.position, eventData.pressEventCamera, ref val2))
					{
						Rect rect = _uiParentRect.rect;
						Vector2 val3 = default(Vector2);
						((Vector2)(ref val3))..ctor(((Rect)(ref rect)).width * _uiParentRect.pivot.x, ((Rect)(ref rect)).height * _uiParentRect.pivot.y);
						Vector2 val4 = _selectStartLocal + val3;
						Vector2 val5 = val2 + val3;
						Vector2 val6 = Vector2.Min(val4, val5);
						Vector2 val7 = Vector2.Max(val4, val5);
						Vector2 sizeDelta = val7 - val6;
						_selectionRect.anchoredPosition = val6;
						_selectionRect.sizeDelta = sizeDelta;
						((Component)_selectionRect).transform.SetAsLastSibling();
					}
					break;
				}
				case 0:
					if (!_isSelecting)
					{
						ScriptParent.transform.position = Vector2.op_Implicit(eventData.position + _offset);
					}
					break;
				case 2:
					break;
				}
			}

			public void OnPointerUp(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				if ((int)eventData.button == 1 && _isSelecting)
				{
					Vector2 position = eventData.position;
					Vector2 val = Vector2.Min(_selectStartScreen, position);
					Vector2 val2 = Vector2.Max(_selectStartScreen, position);
					Rect selectionRect = default(Rect);
					((Rect)(ref selectionRect))..ctor(val, val2 - val);
					if (((Rect)(ref selectionRect)).width < 4f && ((Rect)(ref selectionRect)).height < 4f)
					{
						ScriptManager.ClearSelection();
					}
					else
					{
						DoSelection(selectionRect);
					}
					_isSelecting = false;
					((Component)_selectionImage).gameObject.SetActive(false);
				}
			}

			public static void DoSelection(Rect selectionRect)
			{
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				List<string> list = new List<string>();
				Vector2 val = default(Vector2);
				Vector2 val2 = default(Vector2);
				Rect val4 = default(Rect);
				foreach (KeyValuePair<string, ScriptBlock> block in ScriptManager.Blocks)
				{
					ScriptBlock value = block.Value;
					if (value == null || !Object.op_Implicit((Object)(object)value.BlockObject) || !value.BlockObject.activeInHierarchy)
					{
						continue;
					}
					RectTransform component = value.BlockObject.GetComponent<RectTransform>();
					if (!Object.op_Implicit((Object)(object)component))
					{
						continue;
					}
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					component.GetWorldCorners(array);
					((Vector2)(ref val))..ctor(float.MaxValue, float.MaxValue);
					((Vector2)(ref val2))..ctor(float.MinValue, float.MinValue);
					for (int i = 0; i < 4; i++)
					{
						Vector2 val3 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[i]);
						val = Vector2.Min(val, val3);
						val2 = Vector2.Max(val2, val3);
					}
					((Rect)(ref val4))..ctor(val, val2 - val);
					if (((Rect)(ref selectionRect)).Overlaps(val4, true))
					{
						if (value is LinkedBlock linkedBlock)
						{
							linkedBlock.AddExtraIds(list);
						}
						list.Add(value.BlockId);
					}
				}
				ScriptManager.SetSelection(list);
			}

			private void Update()
			{
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_030a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0335: Unknown result type (might be due to invalid IL or missing references)
				//IL_033f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0364: Unknown result type (might be due to invalid IL or missing references)
				//IL_036e: Unknown result type (might be due to invalid IL or missing references)
				//IL_038e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0393: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				if (Settings.Copy.WasPressed)
				{
					CopiedBlocks.Clear();
					CopiedBlocks.AddRange(from id in ScriptManager.SelectedBlockIds
						select ScriptManager.Blocks.GetValueOrDefault(id) into block
						where block?.CanCloneDirectly ?? false
						select block.Clone(""));
					_copyPos = Vector2.op_Implicit(Blocks.transform.InverseTransformPoint(Input.mousePosition));
				}
				if (Settings.Paste.WasPressed)
				{
					List<ScriptBlock> list = new List<ScriptBlock>();
					string idAddition = Guid.NewGuid().ToString().Substring(0, 4);
					foreach (ScriptBlock copiedBlock in CopiedBlocks)
					{
						if (!(copiedBlock is ObjectBlock) || ScriptManager.IsLocal)
						{
							ScriptBlock scriptBlock = copiedBlock.Clone(idAddition, trimStart: true);
							(ScriptManager.IsLocal ? PlacementManager.GetLevelData() : PlacementManager.GetGlobalData()).ScriptBlocks.Add(scriptBlock);
							scriptBlock.Position += Vector2.op_Implicit(Blocks.transform.InverseTransformPoint(Input.mousePosition)) - _copyPos;
							list.Add(scriptBlock);
						}
					}
					foreach (ScriptBlock item in list)
					{
						item.Setup(visual: true);
					}
					foreach (ScriptBlock item2 in list)
					{
						item2.LateSetup();
					}
					ScriptManager.SetSelection(list.Select((ScriptBlock c) => c.BlockId));
				}
				if (_isSelecting && Object.op_Implicit((Object)(object)_selectionImage) && ((Component)_selectionImage).gameObject.activeSelf && Settings.CreateNewComment.WasPressed)
				{
					CreateCommentFromSelection();
					_isSelecting = false;
					((Component)_selectionImage).gameObject.SetActive(false);
				}
				else if (Input.mouseScrollDelta.y != 0f)
				{
					Deletable.DeleteButton.SetActive(false);
					Transform parent = ScriptParent.transform.parent;
					((Component)_blockTransformSource).transform.position = Input.mousePosition;
					_blockTransformSource.localScale = ScriptParent.transform.localScale;
					ScriptParent.transform.SetParent(_blockTransformSource, true);
					_blockTransformSource.localScale = Vector2.op_Implicit(new Vector2(Mathf.Clamp(_blockTransformSource.localScale.x + Input.mouseScrollDelta.y / 40f, 0.1f, 2f), Mathf.Clamp(_blockTransformSource.localScale.y + Input.mouseScrollDelta.y / 40f, 0.1f, 2f)));
					ScriptParent.transform.SetParent(parent, true);
				}
			}

			private void CreateCommentFromSelection()
			{
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Expected O, but got Unknown
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0208: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_0280: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dc: 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_02e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0333: Unknown result type (might be due to invalid IL or missing references)
				//IL_0357: Unknown result type (might be due to invalid IL or missing references)
				//IL_036e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0385: Unknown result type (might be due to invalid IL or missing references)
				//IL_0392: Unknown result type (might be due to invalid IL or missing references)
				//IL_0397: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_045c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0466: Expected O, but got Unknown
				//IL_046c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0473: Expected O, but got Unknown
				//IL_0497: Unknown result type (might be due to invalid IL or missing references)
				//IL_049c: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0507: Unknown result type (might be due to invalid IL or missing references)
				//IL_0526: Unknown result type (might be due to invalid IL or missing references)
				//IL_0558: Unknown result type (might be due to invalid IL or missing references)
				//IL_057a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0584: Expected O, but got Unknown
				//IL_058c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0591: Unknown result type (might be due to invalid IL or missing references)
				//IL_0596: Unknown result type (might be due to invalid IL or missing references)
				//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0603: Unknown result type (might be due to invalid IL or missing references)
				//IL_0610: Unknown result type (might be due to invalid IL or missing references)
				//IL_061d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0634: Unknown result type (might be due to invalid IL or missing references)
				//IL_0660: Unknown result type (might be due to invalid IL or missing references)
				//IL_0667: Expected O, but got Unknown
				//IL_068b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0690: Unknown result type (might be due to invalid IL or missing references)
				//IL_06bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0719: Unknown result type (might be due to invalid IL or missing references)
				//IL_074e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0770: Unknown result type (might be due to invalid IL or missing references)
				//IL_077a: Expected O, but got Unknown
				if (!Object.op_Implicit((Object)(object)_selectionRect))
				{
					return;
				}
				GameObject scriptParent = ScriptParent;
				if (!Object.op_Implicit((Object)(object)scriptParent))
				{
					return;
				}
				RectTransform component = scriptParent.GetComponent<RectTransform>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					return;
				}
				GameObject val = (ScriptManager.IsLocal ? _localComments : _globalComments);
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = scriptParent;
				}
				RectTransform val2 = val.GetComponent<RectTransform>();
				if (!Object.op_Implicit((Object)(object)val2))
				{
					val2 = component;
				}
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				_selectionRect.GetWorldCorners(array);
				Vector3 val3 = array[0];
				Vector3 val4 = array[2];
				Vector3 val5 = (val3 + val4) * 0.5f;
				GameObject commentObj = new GameObject("Comment");
				RectTransform val6 = commentObj.AddComponent<RectTransform>();
				commentObj.transform.SetParent(val.transform, false);
				Vector2 val7 = default(Vector2);
				((Vector2)(ref val7))..ctor(0.5f, 0.5f);
				val6.anchorMax = val7;
				val6.anchorMin = val7;
				val6.pivot = new Vector2(0.5f, 0.5f);
				((Transform)val6).localRotation = Quaternion.identity;
				((Transform)val6).localScale = Vector3.one;
				Vector2 val8 = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, RectTransformUtility.WorldToScreenPoint((Camera)null, val5), (Camera)null, ref val8);
				val6.anchoredPosition = val8;
				Vector2 val9 = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, RectTransformUtility.WorldToScreenPoint((Camera)null, val3), (Camera)null, ref val9);
				Vector2 val10 = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, RectTransformUtility.WorldToScreenPoint((Camera)null, val4), (Camera)null, ref val10);
				val6.sizeDelta = new Vector2(Mathf.Abs(val10.x - val9.x), Mathf.Abs(val10.y - val9.y));
				commentObj.transform.SetAsFirstSibling();
				bool isLocal = ScriptManager.IsLocal;
				Comment comment = new Comment("Comment", new Color(0f, 0f, 0f, 0.25f), val8, val6.sizeDelta, isLocal);
				LevelData levelData = (isLocal ? PlacementManager.GetLevelData() : PlacementManager.GetGlobalData());
				levelData.Comments.Add(comment);
				CommentData commentData = commentObj.AddComponent<CommentData>();
				commentData.Comment = comment;
				Image img = commentObj.AddComponent<Image>();
				img.sprite = UIUtils.Square;
				((Graphic)img).color = comment.Color;
				Outline val11 = commentObj.AddComponent<Outline>();
				((Shadow)val11).effectColor = new Color(0f, 0f, 0f, 0.6f);
				((Shadow)val11).effectDistance = new Vector2(2f, 2f);
				UIUtils.Label titleLabel = UIUtils.MakeLabel("Comment Title", commentObj, Vector2.zero, Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1);
				((Text)titleLabel.textComponent).text = "Comment";
				((Text)titleLabel.textComponent).alignment = (TextAnchor)4;
				((Graphic)titleLabel.textComponent).color = Color.white;
				RectTransform component2 = ((Component)titleLabel).GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0.5f, 1f);
				component2.anchorMax = new Vector2(0.5f, 1f);
				component2.pivot = new Vector2(0.5f, 0f);
				Rect rect = val6.rect;
				float num = ((Rect)(ref rect)).height * 0.25f;
				rect = val6.rect;
				component2.sizeDelta = new Vector2(((Rect)(ref rect)).width, num);
				float num2 = Mathf.Min(num * 0.05f, 6f);
				component2.anchoredPosition = new Vector2(0f, num2);
				((Text)titleLabel.textComponent).fontSize = Mathf.Clamp(Mathf.RoundToInt(num * 0.6f), 12, 144);
				((Graphic)titleLabel.textComponent).raycastTarget = true;
				((Component)titleLabel).transform.SetAsLastSibling();
				Button val12 = ((Component)titleLabel).gameObject.AddComponent<Button>();
				((UnityEvent)val12.onClick).AddListener((UnityAction)delegate
				{
					StartEditingCommentTitleStatic(titleLabel, commentObj);
				});
				GameObject val13 = new GameObject("CloseButton");
				val13.transform.SetParent(commentObj.transform, false);
				RectTransform val14 = val13.AddComponent<RectTransform>();
				rect = val6.rect;
				float num3 = Mathf.Clamp(((Rect)(ref rect)).height * 0.15f, 16f, 192f);
				val14.sizeDelta = new Vector2(num3, num3);
				val14.anchorMin = new Vector2(1f, 1f);
				val14.anchorMax = new Vector2(1f, 1f);
				val14.pivot = new Vector2(1f, 1f);
				val14.anchoredPosition = new Vector2((0f - num3) * 0.2f, (0f - num3) * 0.2f);
				Image val15 = val13.AddComponent<Image>();
				val15.sprite = UIUtils.Square;
				((Graphic)val15).color = new Color(0.8f, 0.2f, 0.2f);
				Button val16 = val13.AddComponent<Button>();
				((UnityEvent)val16.onClick).AddListener((UnityAction)delegate
				{
					Comment comment3 = commentObj.GetComponent<CommentData>()?.Comment;
					if (comment3 != null)
					{
						LevelData levelData2 = (comment3.IsLocal ? PlacementManager.GetLevelData() : PlacementManager.GetGlobalData());
						levelData2.Comments.Remove(comment3);
					}
					Object.Destroy((Object)(object)commentObj);
				});
				UIUtils.Label label = UIUtils.MakeLabel("X Label", val13, Vector2.zero, Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1);
				((Text)label.textComponent).text = "X";
				((Text)label.textComponent).fontSize = Mathf.RoundToInt(num3 * 0.6f);
				((Graphic)label.textComponent).color = Color.white;
				RectTransform component3 = ((Component)label).GetComponent<RectTransform>();
				component3.anchorMin = Vector2.zero;
				component3.anchorMax = Vector2.one;
				component3.offsetMin = Vector2.zero;
				component3.offsetMax = Vector2.zero;
				component3.pivot = new Vector2(0.5f, 0.5f);
				((Text)label.textComponent).alignment = (TextAnchor)4;
				((Graphic)label.textComponent).raycastTarget = false;
				GameObject val17 = new GameObject("ColorButton");
				val17.transform.SetParent(commentObj.transform, false);
				RectTransform val18 = val17.AddComponent<RectTransform>();
				rect = val6.rect;
				float num4 = Mathf.Clamp(((Rect)(ref rect)).height * 0.1f, 12f, 144f);
				val18.anchorMin = new Vector2(0f, 1f);
				val18.sizeDelta = new Vector2(num4, num4);
				val18.anchorMax = new Vector2(0f, 1f);
				val18.pivot = new Vector2(0f, 1f);
				val18.anchoredPosition = new Vector2(num4 * 0.1f, (0f - num4) * 0.1f);
				Image colorImg = val17.AddComponent<Image>();
				colorImg.sprite = UIUtils.Square;
				((Graphic)colorImg).color = ((Graphic)img).color;
				Button val19 = val17.AddComponent<Button>();
				((UnityEvent)val19.onClick).AddListener((UnityAction)delegate
				{
					//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_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_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_007d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0082: Unknown result type (might be due to invalid IL or missing references)
					//IL_008f: Unknown result type (might be due to invalid IL or missing references)
					//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
					//IL_0107: Unknown result type (might be due to invalid IL or missing references)
					Color[] array2 = (Color[])(object)new Color[4]
					{
						new Color(0f, 0f, 0f, 0.25f),
						new Color(0.1f, 0.1f, 0.3f, 0.25f),
						new Color(0.3f, 0.1f, 0.1f, 0.25f),
						new Color(0.1f, 0.3f, 0.1f, 0.25f)
					};
					int num5 = Array.IndexOf(array2, ((Graphic)img).color);
					int num6 = (num5 + 1) % array2.Length;
					((Graphic)img).color = array2[num6];
					((Graphic)colorImg).color = array2[(num6 + 1) % array2.Length];
					CommentData component4 = commentObj.GetComponent<CommentData>();
					if (Object.op_Implicit((Object)(object)component4))
					{
						Comment comment2 = component4.Comment;
						if (comment2 != null)
						{
							comment2.Color = ((Graphic)img).color;
						}
					}
				});
			}
		}

		public static GameObject ToggleParent;

		public static GameObject GlobalParent;

		public static GameObject LocalParent;

		private static GameObject _localBlocks;

		private static GameObject _localLines;

		private static GameObject _globalBlocks;

		private static GameObject _globalLines;

		private static GameObject _localComments;

		private static GameObject _globalComments;

		private static Transform _blockTransformSource;

		public static BackgroundDrag Drag;

		private static Image _bgImg;

		private static Text _bgTxt;

		private static Text _localBtnText;

		private static Text _globalBtnText;

		private static readonly List<ScriptBlock> CopiedBlocks = new List<ScriptBlock>();

		private static Vector2 _copyPos;

		public static GameObject Blocks => ScriptManager.IsLocal ? _localBlocks : _globalBlocks;

		public static GameObject Lines => ScriptManager.IsLocal ? _localLines : _globalLines;

		public static GameObject ScriptParent => ScriptManager.IsLocal ? LocalParent : GlobalParent;

		public static void Init(GameObject scriptUI)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Expected O, but got Unknown
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Expected O, but got Unknown
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Expected O, but got Unknown
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: Expected O, but got Unknown
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0744: Unknown result type (might be due to invalid IL or missing references)
			//IL_0753: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_0771: Unknown result type (might be due to invalid IL or missing references)
			//IL_0787: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0815: Unknown result type (might be due to invalid IL or missing references)
			//IL_081b: Unknown result type (might be due to invalid IL or missing references)
			_bgImg = UIUtils.MakeImage("Background", scriptUI, new Vector2(0f, 2510f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(10000f, 10000f));
			((Graphic)_bgImg).color = Settings.EditorBackgroundColour.Value;
			_bgImg.sprite = UIUtils.Square;
			Drag = ((Component)_bgImg).gameObject.AddComponent<BackgroundDrag>();
			UIUtils.Label label = UIUtils.MakeLabel("Architect Text", scriptUI, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1);
			label.font = "TrajanPro-Bold";
			_bgTxt = (Text)(object)label.textComponent;
			_bgTxt.text = "architect";
			_bgTxt.alignment = (TextAnchor)4;
			_bgTxt.fontSize = 50;
			((Graphic)_bgTxt).raycastTarget = false;
			((Component)label).transform.SetAsLastSibling();
			GameObject val = new GameObject("Transform Source");
			val.transform.parent = scriptUI.transform;
			_blockTransformSource = val.transform;
			GameObject parent = CreateBlankParent("Scripts", scriptUI, 0);
			GlobalParent = CreateBlankParent("Global Script", parent, 0);
			LocalParent = CreateBlankParent("Local Script", parent, 0);
			_localComments = CreateBlankParent("Local Comments", LocalParent, 20);
			_localComments.transform.SetAsFirstSibling();
			_localBlocks = CreateBlankParent("Local Blocks", LocalParent, 20);
			_localLines = CreateBlankParent("Local Lines", LocalParent, 20);
			_globalComments = CreateBlankParent("Global Comments", GlobalParent, 20);
			_globalComments.transform.SetAsFirstSibling();
			_globalBlocks = CreateBlankParent("Global Blocks", GlobalParent, 20);
			_globalLines = CreateBlankParent("Global Lines", GlobalParent, 20);
			Deletable.Init(scriptUI);
			GameObject val2 = new GameObject("Buttons Parent");
			val2.transform.parent = scriptUI.transform;
			GameObject val3 = val2;
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMax = new Vector2(0.5f, 1f);
			val4.anchorMin = new Vector2(0.5f, 1f);
			val4.offsetMax = Vector2.zero;
			val4.offsetMin = Vector2.zero;
			val4.anchoredPosition = new Vector2(0f, -60f);
			Button item = UIUtils.MakeTextButton("Go Left", "⬅", val3, new Vector2(-310f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(50f, 50f)).Item1;
			Button item2 = UIUtils.MakeTextButton("Go Right", "➡", val3, new Vector2(310f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(50f, 50f)).Item1;
			List<Text> labels = new List<Text>();
			int index = 0;
			for (int j = 0; j < 8; j++)
			{
				(Button, UIUtils.Label) tuple = UIUtils.MakeTextButton("Add Object", "[Placeholder]", val3, new Vector2(((float)j - 3.5f) * 75f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), hasOutline: true, new Vector2(200f, 50f));
				Button item3 = tuple.Item1;
				UIUtils.Label item4 = tuple.Item2;
				int i1 = j;
				((UnityEvent)item3.onClick).AddListener((UnityAction)delegate
				{
					if (index + i1 < ScriptManager.CurrentBlocks.Count())
					{
						ScriptBlock scriptBlock = ScriptManager.CurrentBlocks.ElementAt(index + i1).Item1();
						scriptBlock.Setup(visual: true, newBlock: true);
						(ScriptManager.IsLocal ? PlacementManager.GetLevelData() : PlacementManager.GetGlobalData()).ScriptBlocks.Add(scriptBlock);
					}
				});
				labels.Add((Text)(object)item4.textComponent);
			}
			(InputField, UIUtils.Label) tuple2 = UIUtils.MakeTextbox("Search", val3, new Vector2(0f, 25f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), 1000f, 50f);
			InputField item5 = tuple2.Item1;
			UIUtils.Label item6 = tuple2.Item2;
			RectTransform rectTransform = ((Graphic)item6.textComponent).rectTransform;
			rectTransform.sizeDelta /= 3f;
			((Text)item6.textComponent).fontSize = 11;
			((Component)item6).transform.localScale = Vector3.one;
			((UnityEvent<string>)(object)item5.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				ScriptManager.Filter = s;
				index = 0;
				DoRefresh();
			});
			((UnityEvent)item.onClick).AddListener((UnityAction)delegate
			{
				index -= 8;
				if (index < 0)
				{
					index += Mathf.CeilToInt((float)ScriptManager.CurrentBlocks.Count() / 8f) * 8;
				}
				DoRefresh();
			});
			((UnityEvent)item2.onClick).AddListener((UnityAction)delegate
			{
				index += 8;
				int num2 = ScriptManager.CurrentBlocks.Count();
				if (index >= num2)
				{
					index -= Mathf.CeilToInt((float)num2 / 8f) * 8;
				}
				DoRefresh();
			});
			int num = (Architect.Events.Blocks.Category.Categories.Count - 1) * 20;
			Sprite sprite = ResourceUtils.LoadSpriteResource("Flowcharts.middle_white", (FilterMode)0, default(Vector4), 15f);
			foreach (Architect.Events.Blocks.Category category in Architect.Events.Blocks.Category.Categories)
			{
				var (val5, val6, label2) = UIUtils.MakeButtonWithImage(category.Name + " Button", scriptUI, new Vector2(32f, (float)num), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), 64, 32);
				((Text)label2.textComponent).text = category.Name;
				((Text)label2.textComponent).fontSize = 24;
				((Graphic)label2.textComponent).rectTransform.anchoredPosition = new Vector2(0f, -55f);
				val6.sprite = sprite;
				((Graphic)val6).color = category.Colour;
				((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
				{
					ScriptManager.CurrentCategory = category;
					index = 0;
					DoRefresh();
				});
				num -= 40;
			}
			ToggleParent = CreateBlankParent("Mode Toggles", scriptUI, 0);
			_localBtnText = SetupSwitchButton(ToggleParent, local: true, "Local Script", new Vector3(-200f, 20f));
			((Graphic)_localBtnText).color = Color.yellow;
			_globalBtnText = SetupSwitchButton(ToggleParent, local: false, "Global Script", new Vector3(200f, 20f));
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				orig(self);
				GlobalParent.transform.localPosition = Vector3.zero;
				LocalParent.transform.localPosition = Vector3.zero;
			});
			ScriptManager.IsLocal = true;
			DoRefresh();
			if (Settings.PrideMode)
			{
				Image val7 = UIUtils.MakeImage("Flag", LocalParent, new Vector2(360f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(2000f, 100f));
				val7.sprite = ResourceUtils.LoadSpriteResource("rainbow", (FilterMode)0, default(Vector4), 10f);
				((Component)val7).transform.SetAsFirstSibling();
				Extensions.SetRotation2D(((Component)val7).transform, 90f);
				Image val8 = UIUtils.MakeImage("Flag", GlobalParent, new Vector2(360f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(2000f, 100f));
				val8.sprite = ResourceUtils.LoadSpriteResource("trans", (FilterMode)0, default(Vector4), 10f);
				((Component)val8).transform.SetAsFirstSibling();
				Extensions.SetRotation2D(((Component)val8).transform, 90f);
			}
			void DoRefresh()
			{
				(Func<ScriptBlock>, string)[] array = ScriptManager.CurrentBlocks.ToArray();
				for (int k = 0; k < labels.Count; k++)
				{
					labels[k].text = ((array.Length <= index + k) ? "" : array[index + k].Item2);
				}
			}
		}

		private static Text SetupSwitchButton(GameObject parent, bool local, string name, Vector3 pos)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			Vector2 size = default(Vector2);
			((Vector2)(ref size))..ctor(750f, 40f);
			var (val, label) = UIUtils.MakeTextButton(name + " Button", name, parent, Vector2.op_Implicit(pos), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, size);
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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)
				((Graphic)_localBtnText).color = (local ? Color.yellow : Color.white);
				((Graphic)_globalBtnText).color = (local ? Color.white : Color.yellow);
				ScriptManager.IsLocal = local;
				Deletable.DeleteButton.SetActive(false);
			});
			((Text)label.textComponent).fontSize = 8;
			return (Text)(object)label.textComponent;
		}

		private static GameObject CreateBlankParent(string name, GameObject parent, int yOffset)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0022: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.parent = parent.transform;
			GameObject val2 = val;
			RectTransform val3 = val2.AddComponent<RectTransform>();
			val3.anchorMax = Vector2.one;
			val3.anchorMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			val3.offsetMin = Vector2.zero;
			val3.anchoredPosition = new Vector2(0f, (float)yOffset);
			return val2;
		}

		public static void UpdateColour()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			Color value = Settings.EditorBackgroundColour.Value;
			((Graphic)_bgImg).color = value;
			((Graphic)_bgTxt).color = value + new Color((value.r >= 0.9f) ? (-0.1f) : 0.1f, (value.g >= 0.9f) ? (-0.1f) : 0.1f, (value.b >= 0.9f) ? (-0.1f) : 0.1f);
		}

		private static void StartEditingCommentTitleStatic(UIUtils.Label titleLabel, GameObject commentObj)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			((Component)titleLabel).gameObject.SetActive(false);
			GameObject inputObj = new GameObject("TitleInput");
			inputObj.transform.SetParent(commentObj.transform, false);
			RectTransform val = inputObj.AddComponent<RectTransform>();
			RectTransform component = ((Component)titleLabel).GetComponent<RectTransform>();
			val.anchorMin = component.anchorMin;
			val.anchorMax = component.anchorMax;
			val.pivot = component.pivot;
			val.sizeDelta = component.sizeDelta;
			val.anchoredPosition = component.anchoredPosition;
			InputField val2 = inputObj.AddComponent<InputField>();
			GameObject val3 = new GameObject("Text");
			val3.transform.SetParent(inputObj.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			Text val5 = val3.AddComponent<Text>();
			val5.text = ((Text)titleLabel.textComponent).text;
			val5.font = ((Text)titleLabel.textComponent).font;
			val5.fontSize = ((Text)titleLabel.textComponent).fontSize;
			val5.alignment = ((Text)titleLabel.textComponent).alignment;
			((Graphic)val5).color = ((Graphic)titleLabel.textComponent).color;
			((Graphic)val5).raycastTarget = true;
			val2.textComponent = val5;
			val2.text = ((Text)titleLabel.textComponent).text;
			val2.contentType = (ContentType)0;
			val2.lineType = (LineType)0;
			val2.characterLimit = 100;
			GameObject val6 = new GameObject("Placeholder");
			val6.transform.SetParent(inputObj.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = Vector2.zero;
			val7.anchorMax = Vector2.one;
			val7.offsetMin = Vector2.zero;
			val7.offsetMax = Vector2.zero;
			Text val8 = val6.AddComponent<Text>();
			val8.text = "Enter title...";
			val8.font = ((Text)titleLabel.textComponent).font;
			val8.fontSize = ((Text)titleLabel.textComponent).fontSize;
			((Graphic)val8).color = new Color(1f, 1f, 1f, 0.5f);
			val8.alignment = ((Text)titleLabel.textComponent).alignment;
			val2.placeholder = (Graphic)(object)val8;
			Canvas.ForceUpdateCanvases();
			((Selectable)val2).Select();
			val2.ActivateInputField();
			((UnityEvent<string>)(object)val2.onEndEdit).AddListener((UnityAction<string>)delegate(string newText)
			{
				((Text)titleLabel.textComponent).text = newText;
				((Component)titleLabel).gameObject.SetActive(true);
				CommentData component2 = commentObj.GetComponent<CommentData>();
				if (Object.op_Implicit((Object)(object)component2) && component2.Comment != null)
				{
					component2.Comment.Title = newText;
				}
				Object.Destroy((Object)(object)inputObj);
			});
		}

		public static void LoadComments()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			foreach (Transform item in _localComments.transform)
			{
				Transform val = item;
				if (((Object)val).name == "Comment")
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			foreach (Transform item2 in _globalComments.transform)
			{
				Transform val2 = item2;
				if (((Object)val2).name == "Comment")
				{
					Object.Destroy((Object)(object)((Component)val2).gameObject);
				}
			}
			foreach (Comment comment in PlacementManager.GetLevelData().Comments)
			{
				if (comment.IsLocal)
				{
					CreateCommentFromData(comment, _localComments);
				}
			}
			foreach (Comment comment2 in PlacementManager.GetGlobalData().Comments)
			{
				if (!comment2.IsLocal)
				{
					CreateCommentFromData(comment2, _globalComments);
				}
			}
		}

		private static void CreateCommentFromData(Comment commentData, GameObject commentsParentObj)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Expected O, but got Unknown
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Expected O, but got Unknown
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Expected O, but got Unknown
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0568: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Expected O, but got Unknown
			GameObject commentObj = new GameObject("Comment");
			RectTransform val = commentObj.AddComponent<RectTransform>();
			commentObj.transform.SetParent(commentsParentObj.transform, false);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			val.anchorMax = val2;
			val.anchorMin = val2;
			val.pivot = new Vector2(0.5f, 0.5f);
			((Transform)val).localRotation = Quaternion.identity;
			((Transform)val).localScale = Vector3.one;
			val.anchoredPosition = commentData.Position;
			val.sizeDelta = commentData.Size;
			commentObj.transform.SetAsFirstSibling();
			CommentData commentData2 = commentObj.AddComponent<CommentData>();
			commentData2.Comment = commentData;
			Image img = commentObj.AddComponent<Image>();
			img.sprite = UIUtils.Square;
			((Graphic)img).color = commentData.Color;
			Outline val3 = commentObj.AddComponent<Outline>();
			((Shadow)val3).effectColor = new Color(0f, 0f, 0f, 0.6f);
			((Shadow)val3).effectDistance = new Vector2(2f, 2f);
			UIUtils.Label titleLabel = UIUtils.MakeLabel("Comment Title", commentObj, Vector2.zero, Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1);
			((Text)titleLabel.textComponent).text = commentData.Title;
			((Text)titleLabel.textComponent).alignment = (TextAnchor)4;
			((Graphic)titleLabel.textComponent).color = Color.white;
			RectTransform component = ((Component)titleLabel).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 0f);
			Rect rect = val.rect;
			float num = ((Rect)(ref rect)).height * 0.25f;
			rect = val.rect;
			component.sizeDelta = new Vector2(((Rect)(ref rect)).width, num);
			float num2 = Mathf.Min(num * 0.05f, 6f);
			component.anchoredPosition = new Vector2(0f, num2);
			((Text)titleLabel.textComponent).fontSize = Mathf.Clamp(Mathf.RoundToInt(num * 0.6f), 12, 144);
			((Graphic)titleLabel.textComponent).raycastTarget = true;
			((Component)titleLabel).transform.SetAsLastSibling();
			Button val4 = ((Component)titleLabel).gameObject.AddComponent<Button>();
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				StartEditingCommentTitleStatic(titleLabel, commentObj);
			});
			GameObject val5 = new GameObject("CloseButton");
			val5.transform.SetParent(commentObj.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			rect = val.rect;
			float num3 = Mathf.Clamp(((Rect)(ref rect)).height * 0.15f, 16f, 192f);
			val6.sizeDelta = new Vector2(num3, num3);
			val6.anchorMin = new Vector2(1f, 1f);
			val6.anchorMax = new Vector2(1f, 1f);
			val6.pivot = new Vector2(1f, 1f);
			val6.anchoredPosition = new Vector2((0f - num3) * 0.2f, (0f - num3) * 0.2f);
			Image val7 = val5.AddComponent<Image>();
			val7.sprite = UIUtils.Square;
			((Graphic)val7).color = new Color(0.8f, 0.2f, 0.2f);
			Button val8 = val5.AddComponent<Button>();
			((UnityEvent)val8.onClick).AddListener((UnityAction)delegate
			{
				Comment comment2 = commentObj.GetComponent<CommentData>()?.Comment;
				if (comment2 != null)
				{
					LevelData levelData = (comment2.IsLocal ? PlacementManager.GetLevelData() : PlacementManager.GetGlobalData());
					levelData.Comments.Remove(comment2);
				}
				Object.Destroy((Object)(object)commentObj);
			});
			UIUtils.Label label = UIUtils.MakeLabel("X Label", val5, Vector2.zero, Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1);
			((Text)label.textComponent).text = "X";
			((Text)label.textComponent).fontSize = Mathf.RoundToInt(num3 * 0.6f);
			((Graphic)label.textComponent).color = Color.white;
			RectTransform component2 = ((Component)label).GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			component2.pivot = new Vector2(0.5f, 0.5f);
			((Text)label.textComponent).alignment = (TextAnchor)4;
			((Graphic)label.textComponent).raycastTarget = false;
			GameObject val9 = new GameObject("ColorButton");
			val9.transform.SetParent(commentObj.transform, false);
			RectTransform val10 = val9.AddComponent<RectTransform>();
			rect = val.rect;
			float num4 = Mathf.Clamp(((Rect)(ref rect)).height * 0.1f, 12f, 144f);
			val10.sizeDelta = new Vector2(num4, num4);
			val10.anchorMin = new Vector2(0f, 1f);
			val10.anchorMax = new Vector2(0f, 1f);
			val10.pivot = new Vector2(0f, 1f);
			val10.anchoredPosition = new Vector2(num4 * 0.1f, (0f - num4) * 0.1f);
			Image colorImg = val9.AddComponent<Image>();
			colorImg.sprite = UIUtils.Square;
			((Graphic)colorImg).color = ((Graphic)img).color;
			Button val11 = val9.AddComponent<Button>();
			((UnityEvent)val11.onClick).AddListener((UnityAction)delegate
			{
				//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_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_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_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				Color[] array = (Color[])(object)new Color[4]
				{
					new Color(0f, 0f, 0f, 0.25f),
					new Color(0.1f, 0.1f, 0.3f, 0.25f),
					new Color(0.3f, 0.1f, 0.1f, 0.25f),
					new Color(0.1f, 0.3f, 0.1f, 0.25f)
				};
				int num5 = Array.IndexOf(array, ((Graphic)img).color);
				int num6 = (num5 + 1) % array.Length;
				((Graphic)img).color = array[num6];
				((Graphic)colorImg).color = array[(num6 + 1) % array.Length];
				Comment comment = commentObj.GetComponent<CommentData>()?.Comment;
				if (comment != null)
				{
					comment.Color = ((Graphic)img).color;
				}
			});
		}
	}
	public static class WorkshopUI
	{
		private class Listing : MonoBehaviour
		{
			public GameObject obj;

			public Image icon;

			public Text type;

			public Text id;

			public WorkshopItem CurrentItem;

			public void Clear()
			{
				obj.SetActive(false);
			}

			public void Setup(WorkshopItem item)
			{
				CurrentItem = item;
				icon.sprite = item.GetIcon() ?? SharerManager.Placeholder;
				type.text = item.Type;
				id.text = item.Id;
				obj.SetActive(true);
			}
		}

		private class ScaleWithScreenSize : MonoBehaviour
		{
			public Canvas canvas;

			public RectTransform rt;

			public float padding;

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

			private void LateUpdate()
			{
				//IL_000d: 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_003d: Unknown result type (might be due to invalid IL or missing references)
				RectTransform obj = rt;
				float x = rt.sizeDelta.x;
				Rect pixelRect = canvas.pixelRect;
				obj.sizeDelta = new Vector2(x, ((Rect)(ref pixelRect)).height / canvas.scaleFactor - padding);
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__11_0;

			public static UnityAction <>9__11_1;

			public static Func<WorkshopItem, bool> <>9__11_7;

			public static Func<WorkshopItem, bool> <>9__11_8;

			public static UnityAction <>9__11_3;

			public static UnityAction <>9__11_4;

			public static UnityAction<string> <>9__11_5;

			public static Func<WorkshopItem, bool> <>9__11_11;

			public static Func<WorkshopItem, bool> <>9__13_0;

			public static Func<List<Architect.Workshop.Types.ConfigType>, IEnumerable<Architect.Workshop.Types.ConfigType>> <>9__20_0;

			public static Func<List<Architect.Workshop.Types.ConfigType>, IEnumerable<Architect.Workshop.Types.ConfigType>> <>9__20_1;

			internal void <Init>b__11_0()
			{
				Delete();
				_configArea.SetActive(false);
				_openArea.SetActive(true);
				Refresh();
				static void Delete()
				{
					WorkshopItem workshopItem = WorkshopManager.WorkshopData.Items.FirstOrDefault((WorkshopItem i) => i.Id == _currentId);
					if (workshopItem != null)
					{
						workshopItem.Unregister();
						WorkshopManager.WorkshopData.Items.Remove(workshopItem);
					}
				}
			}

			internal void <Init>b__11_1()
			{
				if (!_saved)
				{
					Delete();
				}
				_configArea.SetActive(false);
				_openArea.SetActive(true);
				Refresh();
				static void Delete()
				{
					WorkshopItem workshopItem = WorkshopManager.WorkshopData.Items.FirstOrDefault((WorkshopItem i) => i.Id == _currentId);
					if (workshopItem != null)
					{
						workshopItem.Unregister();
						WorkshopManager.WorkshopData.Items.Remove(workshopItem);
					}
				}
			}

			internal bool <Init>b__11_7(WorkshopItem i)
			{
				return i.Id == _idField.text;
			}

			internal bool <Init>b__11_8(WorkshopItem i)
			{
				return i.Id == _currentId;
			}

			internal void <Init>b__11_3()
			{
				_pageNum--;
				Search();
			}

			internal void <Init>b__11_4()
			{
				_pageNum++;
				Search();
			}

			internal void <Init>b__11_5(string _)
			{
				_pageNum = 0;
				Search();
			}

			internal bool <Init>b__11_11(WorkshopItem i)
			{
				return i.Id == _currentId;
			}

			internal bool <Search>b__13_0(WorkshopItem o)
			{
				return o.Id.ToLower().Contains(_search.text.ToLower());
			}

			internal IEnumerable<Architect.Workshop.Types.ConfigType> <Open>b__20_0(List<Architect.Workshop.Types.ConfigType> o)
			{
				return o;
			}

			internal IEnumerable<Architect.Workshop.Types.ConfigType> <Open>b__20_1(List<Architect.Workshop.Types.ConfigType> o)
			{
				return o;
			}
		}

		private static GameObject _configArea;

		private static GameObject _openArea;

		private static Text _title;

		private static Image _icon;

		private static InputField _idField;

		private static ScrollRect _scrollRect;

		private static InputField _search;

		private static int _pageNum;

		private static int _pageMax;

		private static Text _pageCounter;

		private static readonly List<Listing> Listings = new List<Listing>();

		private static GameObject _configParent;

		private static string _currentId;

		private static bool _saved;

		public static void Init(GameObject workshopUI)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: 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_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Expected O, but got Unknown
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Expected O, but got Unknown
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0608: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Expected O, but got Unknown
			//IL_0752: Unknown result type (might be due to invalid IL or missing references)
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			//IL_0770: Unknown result type (might be due to invalid IL or missing references)
			//IL_0780: Unknown result type (might be due to invalid IL or missing references)
			//IL_0728: Unknown result type (might be due to invalid IL or missing references)
			//IL_072d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0733: Expected O, but got Unknown
			//IL_07e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0806: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ce: Expected O, but got Unknown
			//IL_0853: Unknown result type (might be due to invalid IL or missing references)
			//IL_085a: Expected O, but got Unknown
			//IL_0888: Unknown result type (might be due to invalid IL or missing references)
			//IL_088d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0892: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0908: Unknown result type (might be due to invalid IL or missing references)
			//IL_090d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0912: Unknown result type (might be due to invalid IL or missing references)
			//IL_094e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0953: Unknown result type (might be due to invalid IL or missing references)
			//IL_0958: Unknown result type (might be due to invalid IL or missing references)
			//IL_0960: Unknown result type (might be due to invalid IL or missing references)
			//IL_0966: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fc: Expected O, but got Unknown
			//IL_0a27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a83: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a95: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b24: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b57: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b76: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb7: Expected O, but got Unknown
			GameObject val = new GameObject("Background");
			val.transform.SetParent(workshopUI.transform, false);
			val.RemoveOffset();
			((RectTransform)val.transform).anchoredPosition = new Vector2(0f, -40f);
			Image val2 = UIUtils.MakeImage("Image", val, new Vector2(0f, 2510f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(10000f, 10000f));
			((Graphic)val2).color = new Color(0f, 0f, 0.15f);
			val2.sprite = UIUtils.Square;
			UIUtils.Label label = UIUtils.MakeLabel("Architect Text", val, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1);
			label.font = "TrajanPro-Bold";
			UIUtils.TruncatableText textComponent = label.textComponent;
			((Text)textComponent).text = "architect";
			((Text)textComponent).alignment = (TextAnchor)4;
			((Text)textComponent).fontSize = 50;
			((Component)label).transform.SetAsLastSibling();
			((Graphic)textComponent).color = new Color(0.1f, 0.1f, 0.4f);
			_openArea = new GameObject("Open Area");
			_openArea.transform.SetParent(workshopUI.transform, false);
			_openArea.RemoveOffset();
			_configArea = new GameObject("Config Area");
			_configArea.transform.SetParent(workshopUI.transform, false);
			_configArea.RemoveOffset();
			_configArea.SetActive(false);
			((RectTransform)_configArea.transform).anchoredPosition = new Vector2(0f, -40f);
			_title = (Text)(object)UIUtils.MakeLabel("Title", _configArea, new Vector2(0f, -75f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			UIUtils.TruncatableText issue = UIUtils.MakeLabel("Issue", _configArea, new Vector2(0f, 75f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			((Text)issue).alignment = (TextAnchor)4;
			var (val3, label2) = UIUtils.MakeTextButton("Delete", "Delete", _configArea, new Vector2(-100f, 35f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(260f, 80f));
			((Text)label2.textComponent).fontSize = 18;
			ButtonClickedEvent onClick = val3.onClick;
			object obj = <>c.<>9__11_0;
			if (obj == null)
			{
				UnityAction val4 = delegate
				{
					Delete();
					_configArea.SetActive(false);
					_openArea.SetActive(true);
					Refresh();
				};
				<>c.<>9__11_0 = val4;
				obj = (object)val4;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			var (val5, label3) = UIUtils.MakeTextButton("Close", "Close", _configArea, new Vector2(0f, 35f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(260f, 80f));
			((Text)label3.textComponent).fontSize = 18;
			ButtonClickedEvent onClick2 = val5.onClick;
			object obj2 = <>c.<>9__11_1;
			if (obj2 == null)
			{
				UnityAction val6 = delegate
				{
					if (!_saved)
					{
						Delete();
					}
					_configArea.SetActive(false);
					_openArea.SetActive(true);
					Refresh();
				};
				<>c.<>9__11_1 = val6;
				obj2 = (object)val6;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			var (val7, label4) = UIUtils.MakeTextButton("Save", "Save", _configArea, new Vector2(100f, 35f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(260f, 80f));
			((Text)label4.textComponent).fontSize = 18;
			_icon = UIUtils.MakeImage("Preview", _configArea, new Vector2(-180f, 40f), new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(200f, 200f));
			_icon.preserveAspect = true;
			UIUtils.Label label5;
			(_idField, label5) = UIUtils.MakeTextbox("Id", _configArea, new Vector2(-180f, -30f), new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), 280f, 50f, 12);
			((Component)label5).transform.localScale = Vector3.one;
			RectTransform val8 = (RectTransform)((Component)label5).transform;
			val8.sizeDelta /= 3f;
			((UnityEvent)val7.onClick).AddListener((UnityAction)delegate
			{
				if (Utility.IsNullOrWhiteSpace(_idField.text) || _idField.text.StartsWith("Prefab") || _idField.text.EndsWith("_Boss") || _idField.text.EndsWith("_Title"))
				{
					((Text)issue).text = "Invalid ID";
				}
				else
				{
					WorkshopItem workshopItem2 = WorkshopManager.WorkshopData.Items.FirstOrDefault((WorkshopItem i) => i.Id == _idField.text);
					WorkshopItem workshopItem3 = WorkshopManager.WorkshopData.Items.FirstOrDefault((WorkshopItem i) => i.Id == _currentId);
					if (workshopItem2 != null && workshopItem2 != workshopItem3)
					{
						((Text)issue).text = "Object with this ID exists";
					}
					else if (workshopItem3 != null)
					{
						workshopItem3.Unregister();
						_currentId = _idField.text;
						workshopItem3.Id = _idField.text;
						workshopItem3.Register();
						_saved = true;
						StorageManager.SaveWorkshopData();
						((Text)issue).text = "Saved Object";
					}
				}
			});
			val.transform.SetAsFirstSibling();
			GameObject val9;
			GameObject val10;
			(_scrollRect, val9, val10) = UIUtils.MakeScrollView("Scroll", _openArea, new Vector2(175f, -40f), new Vector2(200f, 0f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(335f, 350f), 1520);
			val10.transform.localScale = Vector3.one;
			((RectTransform)val10.transform).sizeDelta = Vector2.op_Implicit(new Vector3(20f, 1f));
			Transform child = val10.transform.GetChild(1);
			child.localScale = Vector3.one;
			((RectTransform)child).sizeDelta = Vector2.one;
			VerticalLayoutGroup component = val9.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)component).spacing = 120f;
			_scrollRect.verticalNormalizedPosition = 1f;
			((Component)_scrollRect).gameObject.AddComponent<ScaleWithScreenSize>().padding = 150f;
			val10.gameObject.AddComponent<ScaleWithScreenSize>().padding = 180f;
			var (val11, label6) = UIUtils.MakeTextButton("Left", "<=", _openArea, new Vector2(100f, 0f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(100f, 100f));
			((Text)label6.textComponent).fontSize = 15;
			ButtonClickedEvent onClick3 = val11.onClick;
			object obj3 = <>c.<>9__11_3;
			if (obj3 == null)
			{
				UnityAction val12 = delegate
				{
					_pageNum--;
					Search();
				};
				<>c.<>9__11_3 = val12;
				obj3 = (object)val12;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			var (val13, label7) = UIUtils.MakeTextButton("Right", "=>", _openArea, new Vector2(250f, 0f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), hasOutline: true, new Vector2(100f, 100f));
			((Text)label7.textComponent).fontSize = 15;
			ButtonClickedEvent onClick4 = val13.onClick;
			object obj4 = <>c.<>9__11_4;
			if (obj4 == null)
			{
				UnityAction val14 = delegate
				{
					_pageNum++;
					Search();
				};
				<>c.<>9__11_4 = val14;
				obj4 = (object)val14;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			_pageCounter = (Text)(object)UIUtils.MakeLabel("Page Number", _openArea, new Vector2(175f, 0f), new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
			_pageCounter.fontSize = 18;
			_pageCounter.alignment = (TextAnchor)4;
			for (int j = 0; j < 15; j++)
			{
				GameObject val15 = new GameObject("Listing");
				val15.transform.SetParent(val9.transform, false);
				val15.RemoveOffset();
				Image val16 = UIUtils.MakeImage("Icon", val15, new Vector2(70f, -70f), Vector2.zero, Vector2.zero, new Vector2(200f, 200f));
				val16.preserveAspect = true;
				UIUtils.TruncatableText textComponent2 = UIUtils.MakeLabel("Type Label", val15, new Vector2(180f, -65f), Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1).textComponent;
				((Text)textComponent2).fontSize = 18;
				UIUtils.TruncatableText textComponent3 = UIUtils.MakeLabel("ID Label", val15, new Vector2(180f, -100f), Vector2.zero, Vector2.zero, 80f, 80f, (HorizontalWrapMode)1).textComponent;
				((Text)textComponent3).fontSize = 16;
				var (val17, label8) = UIUtils.MakeTextButton("Edit", "Edit", val15, new Vector2(152.5f, -95f), Vector2.zero, Vector2.zero);
				((Text)label8.textComponent).fontSize = 16;
				Listing listingComponent = val15.AddComponent<Listing>();
				listingComponent.obj = val15;
				listingComponent.icon = val16;
				listingComponent.type = (Text)(object)textComponent2;
				listingComponent.id = (Text)(object)textComponent3;
				Listings.Add(listingComponent);
				((UnityEvent)val17.onClick).AddListener((UnityAction)delegate
				{
					if (listingComponent.CurrentItem != null)
					{
						Open(listingComponent.CurrentItem, isNew: false);
					}
				});
			}
			UIUtils.Label label9;
			(_search, label9) = UIUtils.MakeTextbox("Search", _openArea, new Vector2(175f, -90f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), 750f, 65f);
			((Text)label9.textComponent).fontSize = 15;
			((Component)label9).transform.localScale = Vector3.one;
			RectTransform val18 = (RectTransform)((Component)label9).transform;
			val18.sizeDelta /= 3f;
			((UnityEvent<string>)(object)_search.onValueChanged).AddListener((UnityAction<string>)delegate
			{
				_pageNum = 0;
				Search();
			});
			foreach (KeyValuePair<string, (Vector2, Func<string, WorkshopItem>)> workshopItem4 in WorkshopManager.WorkshopItems)
			{
				workshopItem4.Deconstruct(out var key, out var value);
				(Vector2, Func<string, WorkshopItem>) tuple10 = value;
				string text = key;
				var (pos, func) = tuple10;
				var (val19, label10) = UIUtils.MakeTextButton("Create", "Create " + text, _openArea, pos, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), hasOutline: true, new Vector2(440f, 80f));
				((Text)label10.textComponent).fontSize = 18;
				((UnityEvent)val19.onClick).AddListener((UnityAction)delegate
				{
					((Text)issue).text = "";
					Open(func(Guid.NewGuid().ToString().Substring(0, 8)), isNew: true);
				});
			}
			static void Delete()
			{
				WorkshopItem workshopItem = WorkshopManager.WorkshopData.Items.FirstOrDefault((WorkshopItem i) => i.Id == _currentId);
				if (workshopItem != null)
				{
					workshopItem.Unregister();
					WorkshopManager.WorkshopData.Items.Remove(workshopItem);
				}
			}
		}

		public static void Refresh()
		{
			_scrollRect.verticalNormalizedPosition = 1f;
			_search.text = "";
			_pageNum = 0;
			Search();
		}

		private static void Search()
		{
			int i = 0;
			int num = 0;
			WorkshopItem[] array = WorkshopManager.WorkshopData.Items.Where((WorkshopItem o) => o.Id.ToLower().Contains(_search.text.ToLower())).ToArray();
			_pageMax = Mathf.CeilToInt((float)array.Length / 15f);
			if (_pageMax > 0)
			{
				while (_pageNum >= _pageMax)
				{
					_pageNum -= _pageMax;
				}
				while (_pageNum < 0)
				{
					_pageNum += _pageMax;
				}
				WorkshopItem[] array2 = array;
				foreach (WorkshopItem item in array2)
				{
					num++;
					if (num > _pageNum * 15)
					{
						Listings[i].Setup(item);
						i++;
						if (i >= 15)
						{
							break;
						}
					}
				}
			}
			else
			{
				_pageNum = 0;
			}
			_pageCounter.text = $"{_pageNum + 1}/{_pageMax}";
			for (; i < 15; i++)
			{
				Listings[i].Clear();
			}
		}

		public static void RefreshIcon(WorkshopItem item)
		{
			if (item.Id == _currentId)
			{
				_icon.sprite = item.GetIcon() ?? SharerManager.Placeholder;
			}
		}

		public static void Open(WorkshopItem item, bool isNew)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Expected O, but got Unknown
			_saved = !isNew;
			if (isNew)
			{
				GlobalArchitectData.Instance.CurrentMap = "";
				GlobalArchitectData.Instance.CurrentMapId = "";
				WorkshopManager.WorkshopData.Items.Add(item);
				item.Register();
			}
			_title.text = "Creating " + item.Type;
			_currentId = item.Id;
			_idField.text = _currentId;
			RefreshIcon(item);
			_configArea.SetActive(true);
			_openArea.SetActive(false);
			if (Object.op_Implicit((Object)(object)_configParent))
			{
				Object.Destroy((Object)(object)_configParent);
			}
			_configParent = new GameObject("Config Parent");
			_configParent.transform.SetParent(_configArea.transform, false);
			_configParent.RemoveOffset();
			List<Architect.Workshop.Types.ConfigType>[] array = ((item.Config.Length > 3) ? item.Config[..3] : item.Config);
			int num = (2 * array.Length + array.SelectMany((List<Architect.Workshop.Types.ConfigType> o) => o).Count() - 3) * 6;
			int num2 = 0;
			int num3 = 0;
			List<Architect.Workshop.Types.ConfigType>[] config = item.Config;
			foreach (List<Architect.Workshop.Types.ConfigType> list in config)
			{
				if (num2 == 3)
				{
					num = (2 * (item.Config.Length - 3) + item.Config[3..].SelectMany((List<Architect.Workshop.Types.ConfigType> o) => o).Count() - 3) * 6;
					num3 += 200;
				}
				foreach (Architect.Workshop.Types.ConfigType item2 in list)
				{
					Architect.Workshop.Types.ConfigType configType = item2;
					UIUtils.TruncatableText textComponent = UIUtils.MakeLabel("Config Title", _configParent, Vector2.op_Implicit(new Vector3((float)(num3 + 100), (float)num)), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), 80f, 80f, (HorizontalWrapMode)1).textComponent;
					((Text)textComponent).text = configType.Name;
					((Text)textComponent).fontSize = 8;
					((Text)textComponent).alignment = (TextAnchor)3;
					var (btn, _) = UIUtils.MakeTextButton("Config Apply", "Apply", _configParent, new Vector2((float)(num3 + 220), (float)num), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f));
					((Selectable)btn).interactable = false;
					Architect.Workshop.Types.ConfigElement inp = configType.CreateInput(_configParent, btn, new Vector3((float)(num3 + 155), (float)num), (isNew ? configType.GetDefaultValue() : item.CurrentConfig.GetValueOrDefault(configType.Id))?.SerializeValue());
					num -= 12;
					((UnityEvent)btn.onClick).AddListener(new UnityAction(Apply));
					if (isNew)
					{
						Apply();
					}
					void Apply()
					{
						((Selectable)btn).interactable = false;
						string value = inp.GetValue();
						if (value.Length == 0)
						{
							item.CurrentConfig.Remove(configType.Id);
						}
						else
						{
							Architect.Workshop.Types.ConfigValue configValue = configType.Deserialize(inp.GetValue());
							configValue.Setup(item);
							item.CurrentConfig[configType.Id] = configValue;
						}
					}
				}
				num -= 24;
				if (item.Config.Length > 3)
				{
					num2++;
				}
			}
		}
	}
}
namespace Architect.Content
{
	public static class ParticleObjects
	{
		public static readonly List<Architect.Config.Types.ConfigType> Particle = GroupUtils.Merge(Architect.Objects.Groups.ConfigGroup.Stretchable, new List<Architect.Config.Types.ConfigType>(14)
		{
			Architect.Objects.Groups.ConfigGroup.ZOffset,
			Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Play on Start", "particles_play_on_awake", delegate(GameObject o, BoolConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: 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)
					MainModule main6 = ps.main;
					((MainModule)(ref main6)).playOnAwake = value.GetValue();
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Emission Rate", "particles_rate", delegate(GameObject o, IntConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					EmissionModule emission = ps.emission;
					((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit((float)value.GetValue());
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Max Particles", "particles_max", delegate(GameObject o, IntConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: 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)
					MainModule main5 = ps.main;
					((MainModule)(ref main5)).maxParticles = value.GetValue();
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Playback Speed", "particles_speed", delegate(GameObject o, FloatConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: 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)
					MainModule main4 = ps.main;
					((MainModule)(ref main4)).simulationSpeed = value.GetValue();
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new Vector3ConfigType("Velocity", "particles_velocity", delegate(GameObject o, Vector3ConfigValue value)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val2 = value.GetValue();
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_001e: 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_004e: Unknown result type (might be due to invalid IL or missing references)
					//IL_005a: Unknown result type (might be due to invalid IL or missing references)
					//IL_005f: Unknown result type (might be due to invalid IL or missing references)
					VelocityOverLifetimeModule velocityOverLifetime = ps.velocityOverLifetime;
					((VelocityOverLifetimeModule)(ref velocityOverLifetime)).enabled = true;
					((VelocityOverLifetimeModule)(ref velocityOverLifetime)).x = MinMaxCurve.op_Implicit(val2.x);
					((VelocityOverLifetimeModule)(ref velocityOverLifetime)).y = MinMaxCurve.op_Implicit(val2.y);
					((VelocityOverLifetimeModule)(ref velocityOverLifetime)).z = MinMaxCurve.op_Implicit(val2.z);
					ForceOverLifetimeModule forceOverLifetime = ps.forceOverLifetime;
					((ForceOverLifetimeModule)(ref forceOverLifetime)).enabled = false;
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Gravity", "particles_velocity_gravity", delegate(GameObject o, FloatConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					MainModule main3 = ps.main;
					((MainModule)(ref main3)).gravityModifier = MinMaxCurve.op_Implicit(value.GetValue());
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Size Multiplier", "particles_size_mul", delegate(GameObject o, FloatConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: 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)
					SizeOverLifetimeModule sizeOverLifetime = ps.sizeOverLifetime;
					((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
					((SizeOverLifetimeModule)(ref sizeOverLifetime)).sizeMultiplier = ((SizeOverLifetimeModule)(ref sizeOverLifetime)).sizeMultiplier * value.GetValue();
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new FloatConfigType("Lifetime", "particles_lifetime", delegate(GameObject o, FloatConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					MainModule main2 = ps.main;
					((MainModule)(ref main2)).startLifetime = MinMaxCurve.op_Implicit(value.GetValue());
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new ColourConfigType("Colour", "particles_colour", delegate(GameObject o, ColourConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_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)
					MainModule main = ps.main;
					((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(value.GetValue());
					ColorBySpeedModule colorBySpeed = ps.colorBySpeed;
					((ColorBySpeedModule)(ref colorBySpeed)).enabled = false;
					ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
					((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = false;
				});
			}, alpha: true).WithPriority(-1)),
			Architect.Objects.Groups.ConfigGroup.PngUrl,
			Architect.Objects.Groups.ConfigGroup.Aa,
			Architect.Config.ConfigurationManager.RegisterConfigType(new DoubleIntConfigType("Frame Counts", "particles_allframecount", delegate(GameObject o, DoubleIntConfigValue value)
			{
				(int, int) val = value.GetValue();
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: 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)
					TextureSheetAnimationModule textureSheetAnimation2 = ps.textureSheetAnimation;
					((TextureSheetAnimationModule)(ref textureSheetAnimation2)).enabled = true;
					((TextureSheetAnimationModule)(ref textureSheetAnimation2)).numTilesX = val.Item1;
					((TextureSheetAnimationModule)(ref textureSheetAnimation2)).numTilesY = val.Item2;
				});
			}).WithPriority(-1)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new IntConfigType("Frame Cycles", "particles_frame_cycles", delegate(GameObject o, IntConfigValue value)
			{
				o.ApplyToAllComponents<ParticleSystem>((Action<ParticleSystem>)delegate(ParticleSystem ps)
				{
					//IL_0002: 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)
					TextureSheetAnimationModule textureSheetAnimation = ps.textureSheetAnimation;
					((TextureSheetAnimationModule)(ref textureSheetAnimation)).enabled = true;
					((TextureSheetAnimationModule)(ref textureSheetAnimation)).cycleCount = value.GetValue();
				});
			}).WithPriority(-1))
		});

		public static readonly List<Architect.Config.Types.ConfigType> Fish = GroupUtils.Merge(Particle, new List<Architect.Config.Types.ConfigType>(2)
		{
			Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Foreground", "fish_fore", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
				}
			}).WithDefaultValue(value: true)),
			Architect.Config.ConfigurationManager.RegisterConfigType(new BoolConfigType("Background", "fish_back", delegate(GameObject o, BoolConfigValue value)
			{
				if (!value.GetValue())
				{
					((Component)o.transform.GetChild(0)).gameObject.SetActive(false);
				}
			}).WithDefaultValue(value: true))
		});

		public static void Init()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0675: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0723: Unknown result type (might be due to invalid IL or missing references)
			//IL_0729: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			Categories.Effects.Add(new PreloadObject("Confetti Burst", "confetti_burst", ("Aqueduct_05_festival", "Caravan_States/Flea_Games_Start_effect/confetti_burst (1)"), "Appears when the 'Burst' trigger is run.", null, sprite: ResourceUtils.LoadSpriteResource("confetti_burst", (FilterMode)1, default(Vector4), 1500f), preloadAction: MiscFixers.FixConfetti).WithReceiverGroup(ReceiverGroup.Particles).WithInputGroup(InputGroup.Particles).WithConfigGroup(Particle)
				.WithRotationGroup(RotationGroup.All));
			Categories.Effects.Add(new PreloadObject("Fly Swarm Effect", "fly_swarm_effect", ("Arborium_02", "ant_tiny_white_bug_swarm"), null, null, delegate(GameObject o)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				o.AddComponent<ParticleObject>();
				o.transform.GetChild(0).localPosition = Vector3.zero;
				o.transform.GetChild(1).localPosition = Vector3.zero;
				((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(3)).gameObject.SetActive(false);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("fly_swarm", (FilterMode)1, default(Vector4), 62.5f)).WithConfigGroup(Particle));
			Categories.Effects.Add(new PreloadObject("Fish Effect", "fish_effect", ("Memory_Coral_Tower", "Fish/Pt Exit"), null, null, MiscFixers.FixDecoration, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("fish", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithInputGroup(InputGroup.Particles)
				.WithReceiverGroup(ReceiverGroup.Particles)
				.WithConfigGroup(Fish);
			Categories.Effects.Add(new PreloadObject("Grass Effect", "grass_effect", ("Tut_02", "green_grass_tri (6)/Green Grass A"), "Appears when the 'Burst' trigger is run.", null, delegate(GameObject o)
			{
				//IL_0007: 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_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)
				o.transform.localScale = Vector3.one * 4f;
				o.AddComponent<ParticleObject>();
				o.RemoveComponent<ParticleSystemAutoRecycle>();
				EmissionModule emission = o.GetComponent<ParticleSystem>().emission;
				((EmissionModule)(ref emission)).enabled = false;
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("grass_burst", (FilterMode)1, default(Vector4), 62.5f)).WithInputGroup(InputGroup.Particles).WithConfigGroup(Particle).WithReceiverGroup(ReceiverGroup.Grass)).DoIgnoreScale();
			Categories.Effects.Add(new PreloadObject("Maggot Effect", "maggot_effect", ("localpoolprefabs_assets_shared.bundle", "Assets/Prefabs/Effects/hero_maggoted_effect.prefab"), "Appears when the 'Burst' trigger is run.", null, delegate(GameObject o)
			{
				o.AddComponent<ParticleObject>();
				o.RemoveComponent<PlayParticleEffects>();
				o.RemoveComponent<ParticleSystemAutoDisable>();
				((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
			}, preview: false, notSceneBundle: true, ResourceUtils.LoadSpriteResource("maggot_burst", (FilterMode)1, default(Vector4), 62.5f)).WithReceiverGroup(ReceiverGroup.Particles).WithInputGroup(InputGroup.Particles).WithConfigGroup(Particle));
			Categories.Effects.Add(new PreloadObject("Splash Effect", "water_effect", ("Hang_09", "coral_river_chunk/particle_barrel_splash"), null, null, MiscFixers.AddComponent<ParticleObject>, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("water_effect", (FilterMode)1, default(Vector4), 68.75f)).DoIgnoreScale().WithFlipAction(delegate(GameObject o, bool f)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (f)
				{
					ParticleSystem component = o.GetComponent<ParticleSystem>();
					VelocityOverLifetimeModule velocityOverLifetime = component.velocityOverLifetime;
					((VelocityOverLifetimeModule)(ref velocityOverLifetime)).xMultiplier = ((VelocityOverLifetimeModule)(ref velocityOverLifetime)).xMultiplier * -1f;
				}
			}).WithConfigGroup(Particle)
				.WithInputGroup(InputGroup.Particles)
				.WithReceiverGroup(ReceiverGroup.Particles));
			Categories.Effects.Add(new PreloadObject("Feather Effect", "feather_effect", ("Peak_08b", "DJ Get Sequence/Fayforn Ground Sit NPC"), null, delegate(GameObject o)
			{
				o.RemoveComponent<PlayMakerFSM>();
				o.RemoveComponent<AnimatorLookAnimNPC>();
				o.RemoveComponent<NoiseResponder>();
				o.RemoveComponent<AudioSource>();
				int[] array = new int[7] { 0, 1, 2, 3, 4, 6, 7 };
				foreach (int num in array)
				{
					((Component)o.transform.GetChild(num)).gameObject.SetActive(false);
				}
			}, MiscFixers.AddComponent<ParticleObject>, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("feather_effect", (FilterMode)1, default(Vector4), 68.75f)).WithConfigGroup(Particle).WithInputGroup(InputGroup.Particles).WithReceiverGroup(ReceiverGroup.Particles));
			Categories.Effects.Add(new PreloadObject("Steam Effect", "steam_effect", ("Song_10", "Spa Region (1)/Spa Steam (1)"), null, null, delegate(GameObject o)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				o.AddComponent<ParticleObject>();
				Extensions.SetScale2D(o.transform, new Vector2(1f, 1f));
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("steam_effect", (FilterMode)0, default(Vector4), 75.5f)).WithRotationGroup(RotationGroup.All).WithConfigGroup(Particle).WithInputGroup(InputGroup.Particles)
				.WithReceiverGroup(ReceiverGroup.Particles));
			Categories.Effects.Add(new PreloadObject("Bubble Lantern Effect", "bubble_lantern_effect", ("Memory_Coral_Tower", "Group (38)/Coral_lamp_hang_single (1)/crystals_immediate_BG (4)"), null, null, MiscFixers.AddComponent<ParticleObject>, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("bubble_effect", (FilterMode)1, default(Vector4), 137.5f)).WithConfigGroup(Particle).WithInputGroup(InputGroup.Particles).WithReceiverGroup(ReceiverGroup.Particles)).DoIgnoreScale();
			Categories.Effects.Add(new PreloadObject("Bubble Brazier Effect", "bubble_brazier_effect", ("Memory_Coral_Tower", "big_brazier (2)/CT_big_jar (2)/crystals_immediate_BG (10)"), null, null, MiscFixers.AddComponent<ParticleObject>, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("bubble_effect", (FilterMode)1, default(Vector4), 68.75f)).WithConfigGroup(Particle).WithInputGroup(InputGroup.Particles).WithReceiverGroup(ReceiverGroup.Particles));
			Categories.Effects.Add(new PreloadObject("Rain Dots Effect", "rain_dots_effect", ("Memory_Coral_Tower", "rain_dots (26)"), null, null, delegate(GameObject o)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				o.AddComponent<ParticleObject>();
				o.transform.localScale = Vector3.one;
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("rain_dots", (FilterMode)1, default(Vector4), 137.5f)).WithConfigGroup(Particle).WithInputGroup(InputGroup.Particles).WithReceiverGroup(ReceiverGroup.Particles));
			Categories.Effects.Add(new PreloadObject("Snow Effect", "snow_effect", ("Peak_05", "peak_storm_set_mid_strength"), "Affects the whole room.\nRotate the object to rotate the direction of the storm.", preloadAction: MiscFixers.FixDecoration, postSpawnAction: MiscFixers.FixSnow, preview: false, notSceneBundle: false, sprite: ResourceUtils.LoadSpriteResource("snow", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithConfigGroup(Particle)
				.WithInputGroup(InputGroup.Particles)
				.WithReceiverGroup(ReceiverGroup.Particles)
				.WithRotationGroup(RotationGroup.All);
			Categories.Effects.Add(new PreloadObject("Ducts Effect", "wet_particles", ("Aqueduct_03", "waterways_particles (1)"), "Affects the whole room.", null, MiscFixers.FixDecoration, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("drip", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithConfigGroup(Particle)
				.WithInputGroup(InputGroup.Particles)
				.WithReceiverGroup(ReceiverGroup.Particles);
			Categories.Effects.Add(new PreloadObject("Surface Dust Effect", "surface_dust", ("Abandoned_town", "collid"), null, null, MiscFixers.FixDecoration, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("surface_dust", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithConfigGroup(Particle)
				.WithInputGroup(InputGroup.Particles)
				.WithReceiverGroup(ReceiverGroup.Particles);
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_shared.bundle", "Assets/Prefabs/Effects/Particle System/Knight Particles_follow.prefab", delegate(GameObject o)
			{
				Categories.Effects.Add(CreateParticleObject(o, "Bellhart Effect", "default_particles", "default_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Citadel Effect", "song_city_default", "song_city_default"));
				Categories.Effects.Add(CreateParticleObject(o, "Moss Effect", "moss_particles", "moss_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Marrow Effect", "marrow_particles", "bone_forest_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Wormways Effect", "crawl_particles", "crawl_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Hunter's March Effect", "march_particles", "Hunters_March_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Shellwood Effect", "shellwood_particles", "shellwood_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Greymoor Effect", "greymoor_particles", "greymoor_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Smog Effect", "smog_rise_particles", "smog_rise_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Dust Effect", "dust_particles", "dust_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Sand Effect", "blown_sand_particles", "blown_sand_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Sinner's Road Effect", "dustpen_particles", "dustpen_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Fog Canyon Effect", "fog_canyon_particles", "fog_canyon_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Waterways Effect", "waterways_particles", "waterways_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Honey Effect", "honey_particles", "hive_drip_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Deepnest Effect", "deepnest_particles", "Deepnest Particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Whiteward Effect", "ward_particles", "ward_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Wisp Effect", "wisp_particles", "wisp_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Coral Gorge Effect", "gorge_particles", "coral_gorge_particles"));
				Categories.Effects.Add(CreateParticleObject(o, "Abyss Effect", "abyss_particles", "abyss particles"));
			}, notSceneBundle: true));
		}

		private static PlaceableObject CreateParticleObject(GameObject particles, string name, string id, string path)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(((Component)particles.transform.Find(path)).gameObject);
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			FollowCamera val2 = val.AddComponent<FollowCamera>();
			val2.followX = true;
			val2.followY = true;
			val.AddComponent<ParticleObject>();
			CustomObject customObject = new CustomObject(name, id, val, "Affects the whole room.", null, preview: false, ResourceUtils.LoadSpriteResource(id, (FilterMode)0, default(Vector4), 75.5f))
			{
				ParentScale = Vector3.one,
				LossyScale = Vector3.one,
				Offset = new Vector3(0f, 0f, 0f - Extensions.GetPositionZ(val.transform))
			};
			return customObject.WithConfigGroup(Particle).WithInputGroup(InputGroup.Particles).WithReceiverGroup(ReceiverGroup.Particles);
		}
	}
	public static class VanillaObjects
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass6_2
		{
			private sealed class <<AddCitadelObjects>g__ExitLater|18>d : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public <>c__DisplayClass6_2 <>4__this;

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

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

				[DebuggerHidden]
				public <<AddCitadelObjects>g__ExitLater|18>d(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

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

				private bool MoveNext()
				{
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_003c: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitUntil((Func<bool>)(() => !Object.op_Implicit((Object)(object)<>4__this.fsm) || <>4__this.fsm.ActiveStateName != "Open map" || Settings.ToggleEditor.IsPressed));
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						if (!Object.op_Implicit((Object)(object)<>4__this.fsm))
						{
							return false;
						}
						<>4__this.fsm.SendEvent("CONTINUE");
						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 PlayMakerFSM unlock;

			public PlayMakerFSM fsm;

			public GameObject o;

			internal void <AddCitadelObjects>b__15()
			{
				unlock.SendEvent("ACTIVATED");
			}

			internal void <AddCitadelObjects>b__16()
			{
				fsm.SendEvent("FALSE");
			}

			internal void <AddCitadelObjects>b__17()
			{
				o.BroadcastEvent("OnEnter");
				((MonoBehaviour)fsm).StartCoroutine(ExitLater());
				[IteratorStateMachine(typeof(<<AddCitadelObjects>g__ExitLater|18>d))]
				IEnumerator ExitLater()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <<AddCitadelObjects>g__ExitLater|18>d(0)
					{
						<>4__this = this
					};
				}
			}

			internal bool <AddCitadelObjects>b__19()
			{
				return !Object.op_Implicit((Object)(object)fsm) || fsm.ActiveStateName != "Open map" || Settings.ToggleEditor.IsPressed;
			}
		}

		public static void Init()
		{
			AddMossObjects();
			AddMarrowObjects();
			AddDocksObjects();
			AddFieldsObjects();
			AddWormwaysObjects();
			AddMarchObjects();
			AddMoorObjects();
			AddRoadObjects();
			AddWispObjects();
			AddBellObjects();
			AddShellwoodObjects();
			AddStepsObjects();
			AddVoltObjects();
			AddSandsObjects();
			AddMemoriumObjects();
			AddCogworksObjects();
			AddUnderworksObjects();
			AddVaultsObjects();
			AddCitadelObjects();
			AddWhitewardObjects();
			AddSlabObjects();
			AddPeakObjects();
			AddBileObjects();
			AddMistObjects();
			AddDuctObjects();
			AddAbyssObjects();
			AddMemoryObjects();
			AddFleaObjects();
			AddCradleObjects();
			AddSurfaceObjects();
			AddMiscObjects();
			AddToolObjects();
		}

		private static void AddToolObjects()
		{
			Categories.Attacks.Add(new PreloadObject("Ally Wisp", "hero_wisp_fireball", ("localpoolprefabs_assets_shared", "Assets/Prefabs/Heroes/Tools/Hero Wisp Fireball.prefab"), null, MiscFixers.FixAllyWisp, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.AllyWisp));
		}

		private static void AddVoltObjects()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			Categories.Hazards.Add(new PreloadObject("Voltbeam", "coral_lightning_rock", ("Coral_29", "Zap Worm Lightning (2)"), "Works best in small spaces, hitbox is very tall and pink glow extends much further.", sprite: ResourceUtils.LoadSpriteResource("voltbeam", (FilterMode)1, default(Vector4), 10.75f), uiSprite: ResourceUtils.LoadSpriteResource("voltbeam_ui", (FilterMode)1, default(Vector4), 10.75f), preloadAction: MiscFixers.FixRotation, postSpawnAction: HazardFixers.FixZaprock).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Zaprock).WithRotationGroup(RotationGroup.All));
			GameObject sphere = new GameObject("Voltring");
			sphere.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)sphere);
			PreloadManager.RegisterPreload(new BasicPreload("Coral_29", "Boss Scene/Zap Clusters/Cluster 1/Mega Jelly Zap", delegate(GameObject o)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = Object.Instantiate<GameObject>(o, sphere.transform);
				ConstrainPosition val2 = val.AddComponent<ConstrainPosition>();
				val2.localSpace = true;
				val2.constrainX = true;
				val2.constrainY = true;
				val.transform.localPosition = Vector3.zero;
			}));
			Categories.Hazards.Add(new CustomObject("Voltring", "coral_lightning_orb", sphere, null, null, preview: false, ResourceUtils.LoadSpriteResource("voltring", (FilterMode)1, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.Burst));
			Categories.Hazards.Add(new PreloadObject("Voltgrass", "voltgrass", ("Coral_29", "coral_zap_mounds_shortest (10)"), null, sprite: ResourceUtils.LoadSpriteResource("voltgrass", (FilterMode)1, default(Vector4), 64f), postSpawnAction: HazardFixers.FixVoltgrass).WithRotationGroup(RotationGroup.All).WithFlipAction(delegate(GameObject o, bool f)
			{
				if (f)
				{
					Extensions.SetScaleY(o.transform, 0f - Extensions.GetScaleY(o.transform));
					Extensions.SetRotation2D(o.transform, 180f - Extensions.GetRotation2D(o.transform));
				}
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PlayerHazards)).Offset = new Vector3(0.5723f, 1f);
			Categories.Attacks.Add(new PreloadObject("Voltbola", "voltvessel_ball", ("localpoolprefabs_assets_areaarborium.bundle", "Assets/Prefabs/Hornet Enemies/Lightning Bola Ball Enemy.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
		}

		private static void AddSandsObjects()
		{
			AddEnemy("Coral Furm", "coral_spike_goomba", ("Coral_24", "Coral Spike Goomba"), null, notSceneBundle: false, MiscFixers.AddComponent<EnemyFixers.CoralFurm>).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wakeable);
			AddEnemy("Driznit", "coral_conch_shooter", ("Coral_32", "Coral Conch Shooter (1)"), null, notSceneBundle: false, EnemyFixers.FixDriznit).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wakeable).WithReceiverGroup(ReceiverGroup.Wakeable);
			AddEnemy("Driznarga", "coral_conch_shooter_heavy", ("Coral_24", "Coral Conch Shooter Heavy (1)"));
			AddEnemy("Pokenabbin", "pokenabbin", ("Coral_24", "Coral Conch Stabber (1)"), null, notSceneBundle: false, EnemyFixers.FixPatroller).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Patroller);
			AddEnemy("Conchfly", "coral_conch_driller", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 2/Wave 9/Coral Conch Driller"), null, notSceneBundle: false, EnemyFixers.ClearRotation, EnemyFixers.FixDriller);
			AddEnemy("Crustcrawler A", "coral_goomba_m", ("Memory_Coral_Tower", "Enemy Activator Groups/Enemy Activator Low/Enemy Folder/Coral Goomba M (2)"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition);
			AddEnemy("Crustcrawler B", "coral_goomba_l", ("Memory_Coral_Tower", "Enemy Activator Groups/Enemy Activator Low/Enemy Folder/Coral Goomba L"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition);
			AddEnemy("Crustcrag", "coral_goomba_xl", ("Arborium_06", "Coral Goomba Large (1)"), null, notSceneBundle: false, null, delegate(GameObject o)
			{
				PlayMakerFSM val4 = FSMUtility.LocateMyFSM(o, "Behaviour");
				FsmBool patrol = val4.FsmVariables.FindFsmBool("In Patrol Range");
				val4.GetState("Walk").AddAction(delegate
				{
					patrol.value = true;
				}, 5, everyFrame: false);
			}).DoFlipX();
			Categories.Interactable.Add(new PreloadObject("Falling Coral Spike", "coral_spike_fall", ("Memory_Coral_Tower", "Stalactite Group"), null, null, delegate(GameObject o)
			{
				o.AddComponent<MiscFixers.TriggerActivator>();
				((Component)o.transform.GetChild(0).GetChild(4).GetChild(1)).gameObject.layer = LayerMask.NameToLayer("Particle");
				for (int i = 1; i <= 7; i++)
				{
					Object.Destroy((Object)(object)((Component)o.transform.GetChild(i)).gameObject);
				}
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CoralSpike));
			Categories.Hazards.Add(new PreloadObject("Coral Crust S", "coral_crust_s", ("Arborium_06", "Coral Crust Wall Small"), null, delegate(GameObject o)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				foreach (Transform item in o.transform.GetChild(1))
				{
					Transform val3 = item;
					((Component)val3).gameObject.SetActive(false);
				}
				HazardFixers.FixCoralCrust(o);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable).WithRotationGroup(RotationGroup.All).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable));
			Categories.Hazards.Add(new PreloadObject("Coral Crust M", "coral_crust_m", ("Arborium_06", "Coral Crust Wall Mid (1)"), null, delegate(GameObject o)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				foreach (Transform item2 in o.transform.GetChild(0))
				{
					Transform val2 = item2;
					((Component)val2).gameObject.SetActive(false);
				}
				HazardFixers.FixCoralCrust(o);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable).WithRotationGroup(RotationGroup.All).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable));
			Categories.Hazards.Add(new PreloadObject("Coral Crust L", "coral_crust_l", ("Arborium_06", "Coral Crust Wall Tall (3)"), null, delegate(GameObject o)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Expected O, but got Unknown
				((Component)o.transform.GetChild(1)).gameObject.SetActive(true);
				foreach (Transform item3 in o.transform.GetChild(0))
				{
					Transform val = item3;
					((Component)val).gameObject.SetActive(false);
				}
				HazardFixers.FixCoralCrust(o);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable).WithRotationGroup(RotationGroup.All).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable));
			AddEnemy("Kai", "coral_swimmer_fat", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 3/Wave 5 - fish1/Coral Swimmer Fat (1)"), null, notSceneBundle: false, null, EnemyFixers.FixSpearSpawned);
			AddEnemy("Spinebeak Kai", "coral_poke_swimmer", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 3/Wave 5 - fish1/Coral Poke Swimmer"), null, notSceneBundle: false, null, EnemyFixers.FixSpearSpawned);
			AddEnemy("Steelspine Kai", "coral_spike_swimmer", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 2/Wave 7b - Fish/Coral Spike Swimmer (1)"), null, notSceneBundle: false, null, EnemyFixers.FixSpearSpawned);
			AddEnemy("Karaka", "coral_warrior", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 2/Wave 2/Coral Warrior (1)"), null, notSceneBundle: false, null, EnemyFixers.FixKaraka).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Karaka);
			AddEnemy("Corrcrust Karaka", "corrcrust_karaka", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 4/Wave 3/Coral Bubble Brute"), null, notSceneBundle: false, null, EnemyFixers.FixCorrcrustKaraka);
			Categories.Attacks.Add(new PreloadObject("Coral Bubble", "coral_bubble", ("localpoolprefabs_assets_areacoralareamemory", "Assets/Prefabs/Hornet Enemies/Coral Bubble.prefab"), null, delegate(GameObject o)
			{
				FsmState state = FSMUtility.LocateMyFSM(o, "Control").GetState("Init");
				state.DisableAction(3);
				state.DisableAction(4);
				state.DisableAction(6);
			}, MiscFixers.FixBubble, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bubble).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Karak Gor", "karak_gor", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 2/Wave 10/Coral Brawler (1)"), null, notSceneBundle: false, EnemyFixers.FixKarakGor).DoFlipX();
			AddEnemy("Alita", "alita", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 2/Wave 1/Coral Hunter"), null, notSceneBundle: false, null, EnemyFixers.FixAlita);
			AddEnemy("Yuma", "coral_swimmer_small", ("Memory_Coral_Tower", "Enemy Activator Groups/Enemy Activator Low/Enemy Folder/Coral Swimmer Small"));
			AddEnemy("Yumama", "coral_big_jellyfish", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 3/Wave 15b - double jellyfish/Coral Big Jellyfish"), null, notSceneBundle: false, null, EnemyFixers.FixYumama).DoFlipX();
			AddEnemy("Kakri", "coral_flyer", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 1/Wave 5/Coral Flyer"), null, notSceneBundle: false, null, EnemyFixers.FixSpearSpawned);
			AddEnemy("Yago", "coral_flyer_throw", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 3/Wave 2b/Coral Flyer Throw"), null, notSceneBundle: false, null, EnemyFixers.FixSpearSpawned);
			Categories.Interactable.Add(new PreloadObject("Coral Nut", "coral_crust_tree_activator", ("Coral_24", "coral_crust_tree (5)/Coral Crust Tree Activator"), null, preloadAction: InteractableFixers.FixCoralNut, postSpawnAction: InteractableFixers.FixActivator).WithBroadcasterGroup(BroadcasterGroup.ActiveDeactivatable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CoralNut).WithRotationGroup(RotationGroup.Eight));
			Categories.Effects.Add(new PreloadObject("Coral Branch", "coral_crust_tree_branch", ("Coral_24", "coral_crust_tree (9)/BG Activate Parent/Branch 1/Coral Crust Tree Branch")).WithReceiverGroup(ReceiverGroup.Activatable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloverPod).WithRotationGroup(RotationGroup.All));
			Categories.Hazards.Add(new PreloadObject("Coral Spike S", "stomp_spire", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 2/Wave 10/Coral Brawler (1)/Stomp Spire L"), "This spike starts hidden, the 'Activate' trigger will\ncause the spike to come out of the ground.", HazardFixers.FixCoralSpike).WithReceiverGroup(ReceiverGroup.CoralSpike).WithBroadcasterGroup(BroadcasterGroup.Breakable).WithRotationGroup(RotationGroup.Eight));
			Categories.Hazards.Add(new PreloadObject("Coral Spike L", "coral_spike", ("Memory_Coral_Tower", "Boss Scene/Roar Spikes/Spike Holder 1/Coral Spike"), "This spike starts hidden, the 'Activate' trigger will\ncause the spike to come out of the ground.", HazardFixers.FixCoralSpike).WithReceiverGroup(ReceiverGroup.CoralSpike).WithBroadcasterGroup(BroadcasterGroup.Breakable).WithRotationGroup(RotationGroup.Eight)
				.DoFlipX());
			Categories.Platforming.Add(new PreloadObject("Red Coral Spike", "red_coral_spike", ("Coral_24", "coral_crust_tree (5)/Interactive Activate Parent/Branch 1/Coral Crust Tree Spike Red"), null, null, MiscFixers.FixCoral).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Coral)).WithReceiverGroup(ReceiverGroup.Activatable).WithRotationGroup(RotationGroup.All);
			Categories.Platforming.Add(new PreloadObject("Grey Coral Spike", "grey_coral_spike", ("Coral_24", "coral_crust_tree (10)/Interactive Activate Parent/Branch 1/Coral Crust Tree Spike Grey"), null, null, MiscFixers.FixCoral).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Coral).WithReceiverGroup(ReceiverGroup.Activatable).WithRotationGroup(RotationGroup.All));
			Categories.Platforming.Add(new PreloadObject("Growing Coral Platform 1", "small_grey_coral_plat", ("Coral_24", "coral_crust_tree (5)/Interactive Activate Parent/Branch 1/Coral Crust Tree Plat Small Grey"), null, null, MiscFixers.FixCoral).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Coral).WithReceiverGroup(ReceiverGroup.Activatable).WithRotationGroup(RotationGroup.Four));
			Categories.Platforming.Add(new PreloadObject("Growing Coral Platform 2", "small_red_coral_plat", ("Coral_24", "coral_crust_tree (7)/Interactive Activate Parent/Branch 1/Coral Crust Tree Plat Small Red"), null, null, MiscFixers.FixCoral).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Coral).WithReceiverGroup(ReceiverGroup.Activatable).WithRotationGroup(RotationGroup.Four));
			Categories.Platforming.Add(new PreloadObject("Growing Coral Platform 3", "mid_red_coral_plat", ("Coral_24", "coral_crust_tree (5)/Interactive Activate Parent/Branch 1/Coral Crust Tree Plat Mid Red"), null, null, MiscFixers.FixCoral).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Coral).WithReceiverGroup(ReceiverGroup.Activatable).WithRotationGroup(RotationGroup.Four));
			Categories.Platforming.Add(new PreloadObject("Growing Coral Platform 4", "large_red_coral_plat", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 4/Platform Set B/Interactive Activate Parent/Branch 1/Coral Crust Tree Plat Large"), null, null, MiscFixers.FixCoral).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Coral).WithReceiverGroup(ReceiverGroup.Activatable).WithRotationGroup(RotationGroup.Four));
			Categories.Interactable.Add(new PreloadObject("Coral Gate", "coral_gate", ("Memory_Coral_Tower", "Battle Scenes/Battle Scene Chamber 4/Gates/Battle Gate Coral"), null, delegate(GameObject o)
			{
				PlayMakerFSM fsm = o.GetComponent<PlayMakerFSM>();
				fsm.FsmVariables.FindFsmBool("Stay Closed").Value = false;
				fsm.GetState("Blast Open").AddAction(delegate
				{
					fsm.SetState("Opened");
				}, -1, everyFrame: false);
				fsm.GetState("Open Antic").AddAction(delegate
				{
					((Component)o.transform.GetChild(5)).gameObject.SetActive(false);
				}, 0, everyFrame: false);
			}, delegate(GameObject o)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				((Component)o.transform.GetChild(4)).gameObject.RemoveComponent<BoxCollider2D>();
				BoxCollider2D component = o.GetComponent<BoxCollider2D>();
				((Collider2D)component).offset = new Vector2(-0.7f, 0.32f);
				component.size = new Vector2(3.25f, 6.5f);
			}).WithRotationGroup(RotationGroup.Four).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloseableGates).WithReceiverGroup(ReceiverGroup.BattleGate));
			AddSolid("Coral Platform 1", "coral_plat_float", ("Coral_24", "Coral_plat_float_green_medium (1)"));
			AddEnemy("Watcher at the Edge", "watcher", ("Coral_39", "Coral Warrior Grey"), null, notSceneBundle: false, null, EnemyFixers.FixWatcher).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Watcher).WithReceiverGroup(ReceiverGroup.Wakeable).WithBroadcasterGroup(BroadcasterGroup.Bosses)
				.DoFlipX();
			AddEnemy("Crust King Khann", "crust_king", ("Memory_Coral_Tower", "Boss Scene/Coral King"), null, notSceneBundle: false, null, EnemyFixers.FixKhann).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.Bosses);
			Categories.Misc.Add(new PreloadObject("Karaka Statue", "karaka_statue", ("Coral_Tower_01", "Coral_Warrior_break"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable));
		}

		private static void AddRoadObjects()
		{
			AddEnemy("Muckroach", "dustroach", ("Dust_05", "Dustroach"));
			Categories.Attacks.Add(new PreloadObject("Caltrop", "caltrop", ("localpoolprefabs_assets_areadust.bundle", "Assets/Prefabs/Hornet Enemies/Caltrop.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Attacks.Add(new PreloadObject("Caltrop Bola", "caltrop_ball", ("localpoolprefabs_assets_areadust.bundle", "Assets/Prefabs/Hornet Enemies/Caltrop Ball.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Roachcatcher", "roachcatcher", ("Dust_02", "Roachfeeder Short"));
			AddEnemy("Roachfeeder", "roachfeeder", ("Dust_02", "Black Thread States Thread Only Variant/Normal World/Roachfeeder Tall"), null, notSceneBundle: false, delegate(GameObject o)
			{
				((Behaviour)FSMUtility.LocateMyFSM(o, "FSM")).enabled = false;
			}).DoFlipX();
			AddEnemy("Roachkeeper", "roachkeeper", ("Dust_05", "Roachkeeper")).DoFlipX();
			Categories.Interactable.Add(new PreloadObject("Temporary Gate", "greymoor_flip_bridge", ("Dust_02", "greymoor_flip_bridge (1)"), null, delegate(GameObject o)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				Trapdoor component = o.GetComponent<Trapdoor>();
				component.OnOpen.AddListener((UnityAction)delegate
				{
					o.BroadcastEvent("OnOpen");
				});
				component.OnClose.AddListener((UnityAction)delegate
				{
					o.BroadcastEvent("OnClose");
				});
			}).WithRotationGroup(RotationGroup.Four).WithBroadcasterGroup(BroadcasterGroup.TempGate));
			Categories.Interactable.Add(new PreloadObject("Gong", "gong", ("Dust_Chef", "Battle Parent/Kitchen Pipe Gong/kitchen_string_offset/kitchen_string"), null, InteractableFixers.FixGong).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			AddEnemy("Roachserver", "roachserver", ("Dust_Chef", "Battle Parent/Battle Scene/Wave 1/Roachkeeper Chef Tiny"), null, notSceneBundle: false, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.006f);
			}, EnemyFixers.FixRoachserver);
			Categories.Attacks.Add(new PreloadObject("Maggot Blob", "chef_blob", ("localpoolprefabs_assets_areadust.bundle", "Assets/Prefabs/Hornet Enemies/Chef Maggot Blob.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", HazardFixers.FixMaggotBlob, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Misc.Add(new PreloadObject("Silkeater Cocoon", "silkeater", ("Dust_11", "Steel Soul States/Regular/NPC Control/Large Cocoon 1"), null, null, MiscFixers.FixSilkeaterCocoon).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Hanging Silkeater Cocoon", "silkeater_hang", ("Coral_37", "Room_States/Normal/Silk Grub Large Cocoon"), null, null, MiscFixers.FixSilkeaterCocoon).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			Categories.Misc.Add(new PreloadObject("Tiny Hanging Silkeater Cocoon", "silkeater_s_hang", ("Coral_37", "Room_States/Normal/Silk Grub Small Cocoon 2"), null, null, MiscFixers.FixSilkeaterCocoon).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			AddEnemy("Disgraced Chef Lugoli", "disgraced_chef", ("Dust_Chef", "Battle Parent/Battle Scene/Wave 2/Roachkeeper Chef (1)"), null, notSceneBundle: false, null, EnemyFixers.FixLugoli).WithBroadcasterGroup(BroadcasterGroup.Lugoli).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses);
		}

		private static void AddUnderworksObjects()
		{
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			Categories.Npcs.Add(new PreloadObject("Twelfth Architect NPC", "twelfth_architect", ("Under_17", "Architect Scene/Chair/pillar E/pillar D/pillar C/pillar B/pillar A/seat/Architect NPC"), null, null, MiscFixers.FixArchitect).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Platforming.Add(new PreloadObject("Crumbling Rocks 2", "lava_crumble_plat_b", ("Under_19", "lava_crumble_plat")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CrumblePlat));
			AddEnemy("Cogwork Underfly", "understore_auto", ("Under_19", "Understore Automaton"));
			AddEnemy("Cogwork Hauler", "understore_auto_ex", ("Under_19", "Understore Automaton EX (9)")).DoFlipX();
			AddEnemy("Undersweep", "undersweep", ("Under_19", "Pilgrim Staff Understore")).DoFlipX();
			AddEnemy("Underscrub", "underscrub", ("Under_19", "Pilgrim 03 Understore (1)"));
			AddEnemy("Underloft", "undercrank", ("Under_19b", "Understore Thrower")).DoFlipX();
			AddEnemy("Underworker", "underworker", ("Under_10", "Battle Scene/Wave 1/Understore Small"));
			AddEnemy("Underpoke", "underpoke", ("Under_10", "Battle Scene/Wave 2/Understore Poker"), null, notSceneBundle: false, EnemyFixers.FixUnderworksArenaEnemy);
			AddEnemy("Undercrank", "understore_heavy", ("Under_10", "Battle Scene/Wave 6/Understore Heavy (1)"), null, notSceneBundle: false, EnemyFixers.FixUndercrank).DoFlipX();
			AddEnemy("Drapemite", "drapemite", ("Slab_15", "Mite Heavy (1)"));
			AddEnemy("Giant Drapemite", "giant_drapemite", ("Hang_10", "Understore Mite Giant"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition);
			AddEnemy("Drapefly", "drapefly", ("Hang_10", "Citadel Bat"));
			AddEnemy("Drapelord", "drapelord", ("Arborium_11", "Merchant Quest Parent/Quest Active/Battle Scene/Wave 1/Citadel Bat Large"));
			Categories.Hazards.Add(new PreloadObject("Steam Vent", "steam_vent", ("Under_07", "steam_vent_short (3)")).WithRotationGroup(RotationGroup.Four));
			Categories.Interactable.Add(new PreloadObject("Steam Gate", "steam_gate", ("Under_07", "Battle Scene/Gates/steam_vent_short (2)"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(11)).gameObject.SetActive(false);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloseableGates).WithReceiverGroup(ReceiverGroup.BattleGate));
			Categories.Hazards.Add(new PreloadObject("Spiked Grey Cog", "spike_cog_4", ("Under_05", "cog_05_shortcut/before/blocking cogs/Spike Cog 3"), null, null, HazardFixers.FixUnderworksCog).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Cogs));
			Categories.Hazards.Add(new PreloadObject("Spiked Gold Cog", "spike_cog_5", ("Under_05", "cog_05_shortcut/before/blocking cogs/Spike Cog 2"), null, null, HazardFixers.FixUnderworksCog).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Cogs));
			Categories.Platforming.Add(new PreloadObject("Grind Platform", "grind_plat", ("Under_06", "Grind Plat Control/Understore Grind Plat (1)"), null, MiscFixers.FixGrindPlat).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.GrindPlat));
			Categories.Hazards.Add(new PreloadObject("Junk Pipe", "junk_pipe", ("Under_06", "understore_junk_pipe"), null, preloadAction: HazardFixers.FixJunkPipe, postSpawnAction: HazardFixers.FixJunkPipePostSpawn).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.JunkPipe));
			Categories.Npcs.Add(new PreloadObject("Loam NPC", "loam_npc", ("Under_03d", "Black Thread States/Normal World/Understore Large Worker"), null, null, MiscFixers.FixLoam).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			typeof(HeroTreadmill).Hook("OnBeforeHeroConveyor", (Action<Action<HeroTreadmill, Vector2>, HeroTreadmill, Vector2>)delegate(Action<HeroTreadmill, Vector2> orig, HeroTreadmill self, Vector2 velocity)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)self))
				{
					orig(self, velocity);
				}
			});
			PlaceableObject placeableObject = Categories.Platforming.Add(new PreloadObject("Treadmill", "treadmill", ("Under_03d", "Black Thread States/Normal World/Hero Treadmill"), "If the Override Speed is set, the Treadmill will move at a\nconstant speed instead of matching the player.", null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(0)).gameObject.SetActive(false);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("treadmill", (FilterMode)1, default(Vector4), 56f)).WithFlipAction(delegate(GameObject o, bool f)
			{
				if (f)
				{
					Extensions.SetScaleX(o.transform, 0f - Extensions.GetScaleX(o.transform));
					HeroTreadmill component = o.GetComponent<HeroTreadmill>();
					InverseHeroTreadmill obj = o.AddComponent<InverseHeroTreadmill>();
					FieldInfo[] fields = typeof(HeroTreadmill).GetFields(BindingFlags.Instance | BindingFlags.NonPublic);
					foreach (FieldInfo fieldInfo in fields)
					{
						typeof(InverseHeroTreadmill).GetField(fieldInfo.Name, BindingFlags.Instance | BindingFlags.NonPublic).SetValue(obj, fieldInfo.GetValue(component));
					}
					Object.Destroy((Object)(object)component);
				}
			}).WithRotationGroup(RotationGroup.Three).WithRotateAction(delegate(GameObject o, float r)
			{
				Extensions.SetRotation2D(o.transform, r);
				o.GetComponentInChildren<ConveyorBelt>().vertical = r % 180f != 0f;
			})
				.WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Treadmill));
			placeableObject.Offset += new Vector3(3f, 1.5f, 0f);
			AddSolid("Underworks Platform 1", "under_plat_1", ("Under_05", "dock_metal_grate_floor_set (1)"), MiscFixers.FocusFirstChild);
		}

		private static void AddCitadelObjects()
		{
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_073f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Expected O, but got Unknown
			//IL_07a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0811: Unknown result type (might be due to invalid IL or missing references)
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			//IL_0843: Unknown result type (might be due to invalid IL or missing references)
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c01: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c15: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c1a: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Choir Pouncer", "pilgrim_01_song", ("Song_11", "Black Thread States Thread Only Variant/Normal World/Pilgrim 01 Song"));
			AddEnemy("Choir Hornhead", "pilgrim_02_song", ("Song_11", "Pilgrim 02 Song"));
			AddEnemy("Choristor", "choristor", ("localpoolprefabs_assets_areasong.bundle", "Assets/Prefabs/Hornet Enemies/Song Pilgrim 03.prefab"), null, notSceneBundle: true, EnemyFixers.FixChoristor);
			AddEnemy("Envoy", "envoy", ("Song_17", "March Group Control/March Group R/Song Pilgrim 01"), null, notSceneBundle: false, delegate(GameObject o)
			{
				((Behaviour)FSMUtility.LocateMyFSM(o, "call_handmaiden")).enabled = false;
			});
			AddEnemy("Choir Flyer", "choir_flyer", ("Song_11", "Pilgrim 04 Song (2)"), null, notSceneBundle: false, EnemyFixers.FixPatroller).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Patroller);
			AddEnemy("Choir Bellbearer", "pilgrim_03_song", ("Hang_04_boss", "Battle Scene/Wave 3/Pilgrim 03 Song"), null, notSceneBundle: false, null, EnemyFixers.FixForumEnemy);
			AddEnemy("Choir Clapper", "heavy_sentry", ("Hang_04_boss", "Battle Scene/Wave 8 - Heavy Sentry/Song Heavy Sentry"), null, notSceneBundle: false, null, MiscFixers.FixChoirClapper).DoFlipX();
			GameObject choirBombS = new GameObject("[Architect] Choir Bomb S");
			choirBombS.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)choirBombS);
			PlaceableObject bombS = Categories.Attacks.Add(new CustomObject("Rune Bomb S", "choir_bomb_s", choirBombS, "Appears when the 'Activate' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("rune_bomb_small", (FilterMode)1, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.RuneBomb).WithRotationGroup(RotationGroup.All));
			GameObject choirBombL = new GameObject("[Architect] Choir Bomb L");
			choirBombL.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)choirBombL);
			PlaceableObject bombL = Categories.Attacks.Add(new CustomObject("Rune Bomb L", "choir_bomb_l", choirBombL, "Appears when the 'Activate' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("rune_slam_large", (FilterMode)1, default(Vector4), 50f)).WithReceiverGroup(ReceiverGroup.RuneBomb).WithRotationGroup(RotationGroup.All));
			Categories.Attacks.Add(new PreloadObject("Trobbinado", "trobbio_tornado", ("localpoolprefabs_assets_trobbio", "Assets/Prefabs/Hornet Bosses/Trobbio Tornado.prefab"), null, null, null, preview: false, notSceneBundle: true));
			Categories.Attacks.Add(new PreloadObject("Tormented Trobbinado", "t_trobbio_tornado", ("localpoolprefabs_assets_arealibrary", "Assets/Prefabs/Hornet Bosses/Tormented Trobbio Tornado.prefab"), null, null, delegate(GameObject o)
			{
				tk2dSpriteAnimator component = o.GetComponent<tk2dSpriteAnimator>();
				component.defaultClipId = component.GetClipIdByName("Tornado Projectile");
			}, preview: false, notSceneBundle: true));
			Categories.Attacks.Add(new PreloadObject("Trobbiwork", "trobbio_firework", ("Library_13", "Grand Stage Scene/Boss Scene Trobbio/Trapdoor Bursts/Bursts/Burst A"), null, null, MiscFixers.FixTrobbiwork, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("trapdoor", (FilterMode)1, default(Vector4), 80f)).WithReceiverGroup(ReceiverGroup.Trobbiwork));
			Categories.Attacks.Add(new PreloadObject("Tormented Trobbiwork", "t_trobbio_firework", ("Library_13", "Grand Stage Scene/Boss Scene TormentedTrobbio/Trapdoor Bursts/Bursts/Burst A"), null, null, MiscFixers.FixTrobbiwork, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("trapdoor", (FilterMode)1, default(Vector4), 80f)).WithReceiverGroup(ReceiverGroup.Trobbiwork));
			Categories.Attacks.Add(new PreloadObject("Trobbibomb", "trobbio_bomb", ("localpoolprefabs_assets_trobbio", "Assets/Prefabs/Hornet Bosses/Trobbio Bomb.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", HazardFixers.FixTrobbioBomb, null, preview: false, notSceneBundle: true).WithRotateAction(delegate(GameObject o, float r)
			{
				FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmFloat("Rotation").Value = r;
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity)
				.WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Attacks.Add(new PreloadObject("Tormented Trobbibomb", "t_trobbio_bomb", ("localpoolprefabs_assets_arealibrary", "Assets/Prefabs/Hornet Bosses/Trobbio Cross Bomb.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", HazardFixers.FixTrobbioCrossBomb, null, preview: false, notSceneBundle: true).WithRotateAction(delegate(GameObject o, float r)
			{
				FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmFloat("Rotation").Value = r;
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity)
				.WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Trobbio", "trobbio", ("Library_13", "Grand Stage Scene/Boss Scene Trobbio/Trobbio"), null, notSceneBundle: false, null, EnemyFixers.FixRegularTrobbio).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Slowdown).DoFlipX();
			AddEnemy("Tormented Trobbio", "tormented_trobbio", ("Library_13", "Grand Stage Scene/Boss Scene TormentedTrobbio/Tormented Trobbio"), null, notSceneBundle: false, null, EnemyFixers.FixTormentedTrobbio).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Slowdown).DoFlipX();
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_areahang.bundle", "Assets/Prefabs/Hornet Enemies/rune bomb small.prefab", delegate(GameObject o)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				bool activeSelf2 = o.activeSelf;
				o.SetActive(false);
				GameObject val2 = Object.Instantiate<GameObject>(o, choirBombS.transform);
				if (activeSelf2)
				{
					o.SetActive(true);
				}
				bombS.Offset = ((Component)val2.transform.GetChild(1)).transform.localPosition;
			}, notSceneBundle: true));
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_areahang.bundle", "Assets/Prefabs/Hornet Enemies/rune slam.prefab", delegate(GameObject o)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				bool activeSelf = o.activeSelf;
				o.SetActive(false);
				GameObject val = Object.Instantiate<GameObject>(o, choirBombL.transform);
				if (activeSelf)
				{
					o.SetActive(true);
				}
				bombL.Offset = ((Component)val.transform.GetChild(1)).transform.localPosition;
			}, notSceneBundle: true));
			AddEnemy("Minister", "song_admin", ("Hang_04_boss", "Battle Scene/Wave 5 - Song Admins/Song Administrator"), null, notSceneBundle: false, null, EnemyFixers.FixMinister);
			AddEnemy("Maestro", "song_maestro", ("Hang_04_boss", "Battle Scene/Wave 13 - Maestro/Song Pilgrim Maestro"), null, notSceneBundle: false, null, EnemyFixers.FixMaestro).DoFlipX();
			AddEnemy("Choir Elder", "pilgrim_stomper_song", ("Song_11", "Pilgrim Stomper Song"));
			AddEnemy("Reed", "song_reed", ("Hang_04_boss", "Battle Scene/Wave 1/Song Reed"), null, notSceneBundle: false, null, EnemyFixers.FixForumEnemy).DoFlipX();
			AddEnemy("Grand Reed", "song_reed_grand", ("Hang_07", "Black Thread States/Normal World/Unscaler/Song Reed Grand (1)"), null, notSceneBundle: false, EnemyFixers.FixGrandReed, delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").GetState("Init").DisableAction(3);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wakeable).WithReceiverGroup(ReceiverGroup.Wakeable).DoFlipX();
			GameObject sphere = new GameObject("Thread Storm");
			sphere.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)sphere);
			PreloadManager.RegisterPreload(new BasicPreload("Song_25", "Black Thread States/Normal World/Song Reed Grand (2)/grand_reed_spell_sphere", delegate(GameObject o)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				Object.Instantiate<GameObject>(o, sphere.transform).transform.localPosition = new Vector3(0f, 2f);
			}));
			Categories.Attacks.Add(new CustomObject("Thread Storm", "thread_storm", sphere, null, null, preview: false, ResourceUtils.LoadSpriteResource("thread_storm", (FilterMode)1, default(Vector4), 40f)).WithReceiverGroup(ReceiverGroup.Burst));
			AddEnemy("Clawmaiden", "clawmaiden", ("localpoolprefabs_assets_areahangareasong.bundle", "Assets/Prefabs/Hornet Enemies/Song Handmaiden.prefab"), null, notSceneBundle: true, null, EnemyFixers.FixClawmaiden).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Clawmaiden).Offset = Vector3.zero;
			Categories.Interactable.Add(new PreloadObject("Dial Door", "dial_door", ("Song_20b", "Dial Door Bridge"), null, null, sprite: ResourceUtils.LoadSpriteResource("cog_door", (FilterMode)1, default(Vector4), 64f), preloadAction: InteractableFixers.FixDialDoor).WithRotateAction(InteractableFixers.FixDialDoorRot).WithReceiverGroup(ReceiverGroup.DialDoor).WithRotationGroup(RotationGroup.Four));
			Categories.Interactable.Add(new PreloadObject("Citadel Button S", "citadel_button", ("Song_09", "Hornet_pressure_plate_small_persistent"), null, preloadAction: InteractableFixers.FixButtonPreload, postSpawnAction: InteractableFixers.FixButton).WithBroadcasterGroup(BroadcasterGroup.Buttons).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Buttons));
			Categories.Interactable.Add(new PreloadObject("Citadel Button L", "citadel_button_big", ("Coral_10", "Hornet_pressure_plate/Plate"), null, InteractableFixers.FixButton).WithBroadcasterGroup(BroadcasterGroup.Buttons).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Buttons));
			Categories.Interactable.Add(new PreloadObject("Citadel Gate S", "citadel_gate", ("Song_09", "Citadel Switch Gate")).WithReceiverGroup(ReceiverGroup.Gates));
			Categories.Interactable.Add(new PreloadObject("Citadel Gate L", "citadel_gate_big", ("Coral_10", "Song Gate Entrance Right"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
			}).WithReceiverGroup(ReceiverGroup.Gates));
			Categories.Platforming.Add(new PreloadObject("Metronome Platform", "metronome_plat", ("Song_11", "metronome_plat (11)"), null, null, MiscFixers.FixMetronome).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Metronome));
			AddSolid("Citadel Platform 1", "citadel_plat_1", ("Song_Enclave", "sc_plat_float_fat"));
			AddSolid("Citadel Platform 2", "citadel_plat_2", ("Song_11", "sc_plat_float_mid (5)"));
			AddSolid("Citadel Platform 3", "citadel_plat_3", ("Song_12", "Black Thread States/Normal World/sc_plat_float_fat (1)"));
			AddSolid("Citadel Platform 4", "citadel_plat_4", ("Song_01", "sc_plat_float_tall"));
			Categories.Interactable.Add(new PreloadObject("Ring Switch", "harpoon_gate", ("Cog_Dancers", "Black Thread States/Normal World/harpoon_ring_gate"), null, delegate(GameObject o)
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				HarpoonRingSlideLock componentInChildren = o.GetComponentInChildren<HarpoonRingSlideLock>();
				((Object)o.transform.GetChild(5)).name = ((Object)o).name + " Switch";
				componentInChildren.Dropped.AddListener((UnityAction)delegate
				{
					o.BroadcastEvent("OnPull");
					o.BroadcastEvent("FirstPull");
				});
				((PersistentItem<bool>)(object)o.GetComponentInChildren<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
				{
					if (value)
					{
						o.BroadcastEvent("OnPull");
						o.BroadcastEvent("LoadedPulled");
					}
				};
			}, delegate(GameObject o)
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				((Component)o.transform.GetChild(0)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(3)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(4)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
				Transform child = o.transform.GetChild(2);
				child.position -= new Vector3(7.6233f, -6.6127f);
				Transform child2 = o.transform.GetChild(4);
				child2.position -= new Vector3(7.6233f, -6.6127f);
				Transform child3 = o.transform.GetChild(5);
				child3.position -= new Vector3(7.6233f, -6.6127f);
			})).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Levers).WithBroadcasterGroup(BroadcasterGroup.Levers);
			PlaceableObject placeableObject = Categories.Interactable.Add(new PreloadObject("Ventrica Tube", "ventrica_tube", ("Bellway_City", "City Travel Tube"), null, delegate(GameObject o)
			{
				<>c__DisplayClass6_2 CS$<>8__locals1 = new <>c__DisplayClass6_2();
				CS$<>8__locals1.o = o;
				CS$<>8__locals1.unlock = ((Component)CS$<>8__locals1.o.transform.GetChild(4)).GetComponent<PlayMakerFSM>();
				CS$<>8__locals1.unlock.GetState("Inert").AddAction(delegate
				{
					CS$<>8__locals1.unlock.SendEvent("ACTIVATED");
				}, 0, everyFrame: false);
				CS$<>8__locals1.fsm = FSMUtility.LocateMyFSM(CS$<>8__locals1.o, "Tube Travel");
				CS$<>8__locals1.fsm.GetState("Locked?").AddAction(delegate
				{
					CS$<>8__locals1.fsm.SendEvent("FALSE");
				}, 0, everyFrame: false);
				FsmState state = CS$<>8__locals1.fsm.GetState("Open map");
				state.DisableAction(1);
				state.AddAction(delegate
				{
					CS$<>8__locals1.o.BroadcastEvent("OnEnter");
					((MonoBehaviour)CS$<>8__locals1.fsm).StartCoroutine(ExitLater());
				}, -1, everyFrame: false);
				[IteratorStateMachine(typeof(<>c__DisplayClass6_2.<<AddCitadelObjects>g__ExitLater|18>d))]
				IEnumerator ExitLater()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass6_2.<<AddCitadelObjects>g__ExitLater|18>d(0)
					{
						<>4__this = CS$<>8__locals1
					};
				}
			}, delegate(GameObject o)
			{
				for (int i = 2; i <= 7; i++)
				{
					((Component)o.transform.GetChild(3).GetChild(i)).gameObject.SetActive(false);
				}
				for (int j = 13; j <= 25; j++)
				{
					((Component)o.transform.GetChild(3).GetChild(j)).gameObject.SetActive(false);
				}
				((Component)o.transform.GetChild(3).GetChild(12).GetChild(0)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Ventrica).WithInputGroup(InputGroup.Ventrica).WithBroadcasterGroup(BroadcasterGroup.Ventrica)
				.WithReceiverGroup(ReceiverGroup.Ventrica));
			placeableObject.Offset -= new Vector3(0f, 1.5f);
		}

		private static void AddVaultsObjects()
		{
			AddEnemy("Vaultborn", "vaultborn", ("Library_04", "Acolyte Control/Song Scholar Acolyte"), null, notSceneBundle: false, EnemyFixers.FixVaultborn);
			AddEnemy("Lampbearer", "lampbearer", ("Library_04", "Black Thread States/Normal World/Lightbearer (3)"), null, notSceneBundle: false, EnemyFixers.FixPatroller).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.YPatroller).DoFlipX();
			Categories.Attacks.Add(new PreloadObject("Lamp", "lamp_attack", ("localpoolprefabs_assets_arealibrary", "Assets/Prefabs/Enemies/Fungus 1 + 2/Lightbearer Globe Projectile.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Scrollreader", "scrollreader", ("Library_04", "Black Thread States/Normal World/Scrollkeeper"));
			AddEnemy("Vaultkeeper", "vaultkeeper", ("Library_04", "Scholar"));
		}

		private static void AddCradleObjects()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			Categories.Hazards.Add(new PreloadObject("Rubble Field", "rubble_field", ("Cradle_03", "Boss Scene/Rubble Fields/Rubble Field M"), null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(5)).gameObject.SetActive(false);
			}, null, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("rubble", (FilterMode)0, default(Vector4), 10.24f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Stretchable).WithReceiverGroup(ReceiverGroup.Trap)).Offset = new Vector3(0f, -10f);
			Categories.Platforming.Add(new PreloadObject("Moving Cradle Platform", "cradle_plat", ("Cradle_03", "cradle_plat (7)")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CradlePlat).WithReceiverGroup(ReceiverGroup.CrankPlatform).WithRotationGroup(RotationGroup.Four));
			Categories.Platforming.Add(new PreloadObject("Spiked Moving Cradle Platform", "cradle_spiked_plat", ("Cradle_03", "cradle_spike_plat (10)")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CradlePlat).WithReceiverGroup(ReceiverGroup.CrankPlatform));
			Categories.Hazards.Add(new PreloadObject("Cradle Spikes", "cradle_spikes", ("Cradle_03", "cradle_spike_plat (10)/art/Cradle__0004_moving_plat (9)"), null, HazardFixers.FixCradleSpikes).WithRotationGroup(RotationGroup.All));
		}

		private static void AddSurfaceObjects()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			Categories.Platforming.Add(new PreloadObject("Cradle Nut", "cradle_nut", ("Cradle_Destroyed_Challenge_01", "Cradle Challenge Pea Break")));
			Categories.Hazards.Add(MiscObjects.CreateCustomHazard("Brown Vines", "brown_vines", (Vector2[])(object)new Vector2[6]
			{
				new Vector2(-3.672f, -1.265f),
				new Vector2(-2.4f, 0f),
				new Vector2(-1.089f, 0.077f),
				new Vector2(0.874f, 1.282f),
				new Vector2(2.353f, 0.813f),
				new Vector2(3.454f, -1.574f)
			}));
			AddSolid("Surface Platform", "plat_float_06", ("Abandoned_town", "plat_float_06"));
			AddEnemy("Pharlid", "pharlid", ("Cradle_Destroyed_Challenge_02", "Blade Spider")).DoFlipX();
			AddEnemy("Pharlid Diver", "pharlid_diver", ("Cradle_Destroyed_Challenge_02", "Blade Spider Hang"), null, notSceneBundle: false, null, EnemyFixers.FixPharlidDiver);
			Categories.Enemies.Add(new PreloadObject("Garpid", "garpid", ("Cradle_Destroyed_Challenge_01", "Centipede Trap Control/Centipede Trap"), null, null, delegate(GameObject o)
			{
				tk2dSpriteAnimator component = o.GetComponent<tk2dSpriteAnimator>();
				component.defaultClipId = component.GetClipIdByName("Damage Hero");
			})).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Garpid).WithRotateAction(delegate(GameObject o, float rot)
			{
				FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmFloat("Rotation").Value = rot;
			})
				.WithRotationGroup(RotationGroup.All)
				.WithReceiverGroup(ReceiverGroup.Garpid)
				.WithBroadcasterGroup(BroadcasterGroup.Damageable);
			AddEnemy("Imoba", "imoba", ("Cradle_Destroyed_Challenge_01", "Spike Lazy Flyer"), null, notSceneBundle: false, EnemyFixers.FixPatroller).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Patroller);
			AddEnemy("Skrill", "surface_scuttler", ("Abandoned_town", "Surface Scuttler"), null, notSceneBundle: false, null, EnemyFixers.FixSkrill).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SimpleEnemies);
		}

		private static void AddDuctObjects()
		{
			AddEnemy("Spit Squit", "swamp_mosquito_skinny", ("Aqueduct_03", "Swamp Mosquito Skinny"));
			Categories.Attacks.Add(new PreloadObject("Squit Bullet", "muck_bullet", ("localpoolprefabs_assets_areaaqueduct.bundle", "Assets/Prefabs/Hornet Enemies/Skinny Mosquito Bullet.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Barnak", "swamp_barnacle", ("Aqueduct_03", "Swamp Barnacle (1)")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.HideBody).DoFlipX();
			AddEnemy("Ductsucker", "swamp_ductsucker", ("Aqueduct_03", "Swamp Ductsucker"), null, notSceneBundle: false, null, EnemyFixers.FixDuctsucker);
			Categories.Misc.Add(new PreloadObject("Kratt", "caravan_lech_wounded", ("Aqueduct_05_caravan", "Caravan_States/Fleatopia/Caravan Lech/Caravan Lech Wounded"), null, MiscFixers.FixKratt).WithBroadcasterGroup(BroadcasterGroup.Hittable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Kratt));
			Categories.Platforming.Add(new PreloadObject("Trapped Wardenfly", "swamp_barnacle_slab_fly", ("Aqueduct_04", "Swamp Barnacle Slab Fly")));
		}

		private static void AddAbyssObjects()
		{
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Shadow Creeper", "shadow_creeper", ("Abyss_05", "Abyss Crawler (2)")).WithRotationGroup(RotationGroup.Four);
			AddEnemy("Shadow Charger", "shadow_charger", ("Abyss_05", "Abyss Crawler Large (1)")).DoFlipX().WithRotationGroup(RotationGroup.Four);
			AddEnemy("Gloomsac", "gloomsac", ("localpoolprefabs_assets_areaabyss.bundle", "Assets/Prefabs/Hornet Enemies/Gloomfly.prefab"), null, notSceneBundle: true, null, EnemyFixers.FixGloomsac);
			AddEnemy("Gargant Gloom", "gargant_gloom", ("Abyss_02b", "Gloom Beast"), null, notSceneBundle: false, null, EnemyFixers.FixGargantGloom);
			AddSolid("Abyss Platform 1", "abyss_plat_mid", ("Abyss_05", "abyss_plat_mid"));
			AddSolid("Abyss Platform 2", "abyss_plat_wide", ("Abyss_05", "abyss_plat_wide"), MiscFixers.FocusFirstChild);
			Categories.Hazards.Add(new PreloadObject("Void Tendrils", "abyss_tendrils", ("Abyss_07", "Abyss Tendrils (16)"), null, HazardFixers.FixTendrils, delegate(GameObject o)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				o.transform.localScale = new Vector3(1.5f, 1.5f);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Stretchable));
			Categories.Platforming.Add(new PreloadObject("Abyss Pod", "abyss_pod", ("Abyss_05", "Abyss Bounce Pod")));
			GameObject abyssBullet = null;
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_areaabyss", "Assets/Prefabs/Enemies/Abyss Attacks/Abyss Bullet.prefab", delegate(GameObject o)
			{
				abyssBullet = o;
			}, notSceneBundle: true));
			GameObject voidBullet = new GameObject("[Architect] Void Shot");
			voidBullet.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)voidBullet);
			Categories.Attacks.Add(new CustomObject("Void Shot", "void_bullet", voidBullet, "Appears when the 'Activate' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("void_bullet", (FilterMode)1, default(Vector4), 64f)).WithScaleAction(delegate(GameObject o, float s)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = Object.Instantiate<GameObject>(abyssBullet, o.transform);
				val.SetActive(false);
				EnemyBullet component = val.GetComponent<EnemyBullet>();
				component.scaleMin *= s;
				component.scaleMax *= s;
				Transform transform2 = val.transform;
				transform2.localScale *= s;
			}).WithReceiverGroup(ReceiverGroup.VoidBullet));
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_laceboss", "Assets/Prefabs/Hornet Bosses/Lost Lace/Lost Lace Summon Bullet.prefab", delegate(GameObject o)
			{
				bool activeSelf = o.activeSelf;
				o.SetActive(false);
				Object.Instantiate<GameObject>(o, voidBullet.transform);
				if (activeSelf)
				{
					o.SetActive(true);
				}
			}, notSceneBundle: true));
			Categories.Attacks.Add(new PreloadObject("Void Glob", "void_glob", ("localpoolprefabs_assets_areaabyss", "Assets/Prefabs/Enemies/Abyss Attacks/Abyss Vomit Glob.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Hazards.Add(new PreloadObject("Void Tsunami", "void_wave", ("Abyss_Cocoon", "Boss Control/Abyss Wave/Abyss Wave L1"), "Tsunami ends where the object is placed.\n\nThis object activates when enabled, and disables itself when done.\nTo use it multiple times, enable it each time. An Object Spawner is not needed.", null, delegate(GameObject o)
			{
				o.transform.DisableChild(0, 5, 5);
				o.transform.DisableChild(0, 5, 6);
				o.transform.DisableChild(0, 10);
				o.transform.DisableChild(0, 17);
				Object.Destroy((Object)(object)FSMUtility.LocateMyFSM(((Component)o.transform.GetChild(0).GetChild(19)).gameObject, "Catch Hornet"));
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("voidtsu", (FilterMode)1, default(Vector4), 64f)).DoFlipX().WithConfigGroup(Architect.Objects.Groups.ConfigGroup.VoidTsunami)).Offset = new Vector3(7f, 1.8f);
			Categories.Effects.Add(new PreloadObject("Surface Water Effect", "abyss_water", ("Abyss_Cocoon", "Boss Control/Abyss Wave/Abyss Wave L1/abyss_wave/Wave_Antic/abyss_water_top(Clone)"), null, null, delegate(GameObject o)
			{
				Extensions.SetRotation2D(o.transform, 0f);
				Extensions.SetPositionZ(o.transform, 0.006f);
			}).WithScaleAction(delegate(GameObject o, float s)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				Transform transform = o.transform;
				transform.localScale *= s * 1.2f;
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.StretchColourDecor));
		}

		private static void AddMemoryObjects()
		{
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			Categories.Enemies.Add(new PreloadObject("Wingmould", "white_palace_fly", ("Memory_Red", "Scenery Groups/End Scenery/White Palace Fly Red Memory (1)"), null, null, delegate(GameObject o)
			{
				o.GetComponent<Rigidbody2D>().constraints = (RigidbodyConstraints2D)7;
			}).DoFlipX()).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SimpleEnemies).WithReceiverGroup(ReceiverGroup.Enemies)
				.WithBroadcasterGroup(BroadcasterGroup.Damageable);
			Categories.Interactable.Add(new PreloadObject("Reusable Lever", "reusable_lever", ("Memory_Red", "Scenery Groups/Deepnest Scenery/Control Lever"), "Can be pulled multiple times and does not stay pulled.", InteractableFixers.FixReusableLever, delegate(GameObject o)
			{
				Extensions.SetRotation2D(o.transform, 180f);
			}).WithBroadcasterGroup(BroadcasterGroup.Activatable).WithRotationGroup(RotationGroup.Eight));
			Categories.Effects.Add(new PreloadObject("Water Effect", "water_effect_anim", ("Clover_02c", "water_components_moss_short 1/caustic_small_000 (13)"), null, null, delegate(GameObject o)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(5f, 5f));
				Extensions.SetScaleZ(o.transform, 1f);
				Extensions.SetRotation2D(o.transform, 0f);
				Extensions.SetPositionZ(o.transform, 0.06f);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.StretchDecor));
			Categories.Interactable.Add(new PreloadObject("Clover Plant", "clover_pod_activator", ("Clover_02c", "grove_pod (1)/Clover Bounce Pod Activator"), null, InteractableFixers.FixActivator).WithBroadcasterGroup(BroadcasterGroup.ActiveDeactivatable));
			Categories.Platforming.Add(new PreloadObject("Clover Pod", "clover_pod", ("Clover_02c", "grove_pod (1)/Interactive Parent/Clover Bounce Pod (3)")).WithReceiverGroup(ReceiverGroup.Activatable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloverPod));
			Categories.Platforming.Add(new PreloadObject("Memory Platform", "memory_ground_plat", ("Memory_Red", "Scenery Groups/Entry Scenery/memory_ground_plat (6)"), null, null, MiscFixers.FixMemoryPlat));
			Categories.Effects.Add(new PreloadObject("Web Effect", "web_effect", ("Memory_Red", "thread_memory_region/web_particles (1)"), "Affects the whole room.", null, MiscFixers.FixWebDecoration, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("web", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations);
			Categories.Platforming.Add(new PreloadObject("Silk Pod", "silk_pod", ("Memory_Red", "Scenery Groups/Entry Scenery/red_memory_silk_pod0007 (15)")));
			Categories.Platforming.Add(new PreloadObject("Honey Pod", "hive_pod", ("Memory_Red", "Scenery Groups/Hive Scenery/Hive_Break_01")));
			Categories.Misc.Add(new PreloadObject("Shaman Shell S", "shell_small", ("Tut_04", "States/Outro Scene/Snail_Shell_Small"), null, null, MiscFixers.FixShamanShell));
			Categories.Misc.Add(new PreloadObject("Shaman Shell M", "shell_mid", ("Tut_04", "States/Outro Scene/Snail_Shell_Mid"), null, null, MiscFixers.FixShamanShell));
			Categories.Misc.Add(new PreloadObject("Shaman Shell L", "shell_large", ("Tut_04", "States/Outro Scene/Snail_Shell_Large"), null, null, MiscFixers.FixShamanShell));
			AddSolid("Deepnest Platform 1", "deepnest_platform_01", ("Memory_Red", "Scenery Groups/Deepnest Scenery/plat_float_07"));
			AddSolid("Deepnest Platform 2", "deepnest_platform_02", ("Memory_Red", "Scenery Groups/Deepnest Scenery/deepnest_platform_05"));
			AddSolid("Deepnest Platform 3", "deepnest_platform_03", ("Memory_Red", "Scenery Groups/Deepnest Scenery/deepnest_platform_03"));
			AddSolid("Deepnest Platform 4", "deepnest_platform_04", ("Memory_Red", "Scenery Groups/Deepnest Scenery/deepnest_platform_04"));
			AddSolid("Deepnest Platform 5", "deepnest_platform_05", ("Memory_Red", "Scenery Groups/Deepnest Scenery/deepnest_platform_01"));
			AddSolid("Hive Platform 1", "hive_platform_03", ("Memory_Red", "Scenery Groups/Hive Scenery/hive_plat_04 (1)"));
			AddSolid("Hive Platform 2", "hive_platform_02", ("Memory_Red", "Scenery Groups/Hive Scenery/hive_plat_02"));
			AddSolid("Hive Platform 3", "hive_platform_01", ("Memory_Red", "Scenery Groups/Hive Scenery/hive_plat_01"));
			Categories.Interactable.Add(new PreloadObject("Clover Statue", "clover_statue", ("Clover_02c", "Memory Orb Group/Clover_Statue_Break Orb"), null, InteractableFixers.FixCloverStatue).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			Categories.Npcs.Add(new PreloadObject("Green Prince NPC", "green_prince", ("Song_04", "Black Thread States/Normal World/Scene States/Green Prince Stand Song_04"), null, MiscFixers.FixBasicNpc).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Misc.Add(new PreloadObject("Lily Pad / Nuphar", "lilypad", ("Clover_04b", "Lilypad Trap Setter/Lilypad Plat (1)"), null, delegate(GameObject o)
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(o, "Control");
				fsm.GetState("Trap Antic 1").AddAction(delegate
				{
					o.BroadcastEvent("OnActivate");
				}, 0, everyFrame: false);
				fsm.GetState("Activate").AddAction(delegate
				{
					o.BroadcastEvent("OnDeactivate");
				}, -1, everyFrame: false);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Lilypad).WithBroadcasterGroup(BroadcasterGroup.ActiveDeactivatable));
			AddEnemy("Leaf Roller", "leaf_roller", ("Clover_02c", "Grass Goomba")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LeafRoller);
			AddEnemy("Leaf Glider", "leaf_glider", ("Clover_02c", "Lilypad Plat/Lilypad Fly")).DoFlipX();
			AddEnemy("Cloverstag", "cloverstag", ("Clover_06", "Cloverstag (2)"));
			AddEnemy("Kindanir", "kindanir", ("Clover_04b", "Battle Scene/Wave 3/Grasshopper Child (1)"), null, notSceneBundle: false, EnemyFixers.FixFlyin);
			AddEnemy("Verdanir", "verdanir", ("Clover_04b", "Battle Scene/Return Scene/Grasshopper Slasher"));
			AddEnemy("Escalion", "escalion", ("Clover_04b", "Grasshopper Fly")).DoFlipX();
			AddSolid("Verdania Platform 1", "verdania_plat_1", ("Clover_21", "Group/clover_gate_outer_0000_1 (53)"), delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.006f);
			});
			AddSolid("Verdania Platform 2", "verdania_plat_2", ("Clover_21", "Group/clover_gate_outer_0000_1 (54)"), delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.006f);
			});
			AddSolid("Verdania Platform 3", "verdania_plat_3", ("Clover_21", "clover___0019_roof2_plat (5)"));
			Categories.Interactable.Add(new PreloadObject("Verdania Button", "verdania_button", ("Clover_05c", "Hornet_pressure_plate_small_persistent"), null, InteractableFixers.FixButton, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(0)).gameObject.SetActive(false);
			}).WithBroadcasterGroup(BroadcasterGroup.Buttons).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Buttons));
			Categories.Interactable.Add(new PreloadObject("Verdania Gate", "verdania_gate", ("Clover_05c", "Clover Gate (1)"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(3)).gameObject.SetActive(false);
				o.RemoveComponent<PersistentBoolItem>();
			}).WithReceiverGroup(ReceiverGroup.Gates));
			Categories.Effects.Add(new PreloadObject("Background Pendra", "pendra_bg", ("Tut_02", "Tiny Dragonfly (3)")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations));
			AddEnemy("Pendra", "pendra", ("Clover_05c", "Hornet Dragonfly"), null, notSceneBundle: false, null, EnemyFixers.FixPendra);
			AddEnemy("Pendragor", "pendragor", ("Clover_18", "Dragonfly Large"), null, notSceneBundle: false, null, EnemyFixers.FixPendra);
		}

		private static void AddMoorObjects()
		{
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Silk Snipper", "silk_snipper", ("Greymoor_06", "Farmer Scissors"));
			AddEnemy("Dreg Catcher", "dreg_catcher", ("Greymoor_05", "Scene Control/Farmer Enemies/Roosting Enemies/Farmer Catcher (2)"), null, notSceneBundle: false, EnemyFixers.KeepActive);
			AddEnemy("Thread Raker", "thread_raker", ("Greymoor_05", "Scene Control/Farmer Enemies/Farmer Centipede (1)"), null, notSceneBundle: false, EnemyFixers.KeepActiveRemoveConstrainPos, delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").GetState("Init").DisableAction(2);
			});
			Categories.Attacks.Add(new PreloadObject("Pitchfork", "pitchfork", ("localpoolprefabs_assets_areagreymoor", "Assets/Prefabs/Hornet Enemies/Centipede Farmer Projectile.prefab"), null, null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity).WithInputGroup(InputGroup.Velocity));
			AddEnemy("Mite", "mite", ("Greymoor_06", "Mite")).WithRotationGroup(RotationGroup.Three).WithRotateAction(delegate(GameObject o, float f)
			{
				FSMUtility.LocateMyFSM(o, "Control").FsmVariables.FindFsmBool("Eating").Value = f % 180f != 0f;
				Extensions.SetRotation2D(o.transform, f);
			}).DoFlipX();
			AddEnemy("Mitemother", "mitemother", ("Greymoor_16", "Gnat Giant")).DoFlipX();
			AddEnemy("Fluttermite", "mitefly", ("Greymoor_03", "Mitefly (1)"), null, notSceneBundle: false, EnemyFixers.FixPatroller).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.YPatroller);
			AddEnemy("Craw", "crow", ("localpoolprefabs_assets_areagreymoor", "Assets/Prefabs/Hornet Enemies/Crow.prefab"), null, notSceneBundle: true);
			AddEnemy("Tallcraw", "crowman", ("Greymoor_15b", "Crowman"), null, notSceneBundle: false, EnemyFixers.KeepActive);
			AddEnemy("Squatcraw", "crowman_dagger", ("Greymoor_15b", "Crowman Dagger (1)"), null, notSceneBundle: false, EnemyFixers.KeepActive);
			AddEnemy("Craw Juror", "craw_juror", ("Room_CrowCourt_02", "Battle Scene/Wave 2/Crowman Juror Tiny"), null, notSceneBundle: false, EnemyFixers.FixCrawJurorPreload, EnemyFixers.FixTinyCrawJuror);
			AddEnemy("Tallcraw Juror", "tallcraw_juror", ("Room_CrowCourt_02", "Battle Scene/Wave 1/Crowman Juror"), null, notSceneBundle: false, EnemyFixers.FixCrawJurorPreload, EnemyFixers.FixTallcrawJuror);
			AddEnemy("Squatcraw Juror", "squatcraw_juror", ("Room_CrowCourt_02", "Battle Scene/Wave 1/Crowman Dagger Juror"), null, notSceneBundle: false, EnemyFixers.FixCrawJurorPreload, EnemyFixers.FixCrawJuror);
			AddEnemy("Crawfather", "crawfather", ("Room_CrowCourt_02", "Battle Scene/Wave 6/Crawfather"), null, notSceneBundle: false, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.006f);
			}, EnemyFixers.FixCrawfather).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.SummonerBosses);
			Categories.Hazards.Add(new PreloadObject("Craw Chain", "craw_chain", ("Room_CrowCourt_02", "Battle Scene/Wave 6/Crawfather/Chains/Crawfather Attack Chain"), "Starts hidden, the 'Activate' trigger will activate the chain.", delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").GetState("Emerge Pause").DisableAction(2);
			}, delegate(GameObject o)
			{
				tk2dSpriteAnimator component = o.GetComponent<tk2dSpriteAnimator>();
				component.defaultClipId = component.GetClipIdByName("Chain Spike");
			}).WithReceiverGroup(ReceiverGroup.Trap).WithRotationGroup(RotationGroup.All));
			AddEnemy("Moorwing", "moorwing", ("Greymoor_05_boss", "Vampire Gnat Boss Scene/Vampire Gnat"), null, notSceneBundle: false, null, EnemyFixers.FixMoorwing).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Moorwing).WithBroadcasterGroup(BroadcasterGroup.Bosses).DoFlipX();
			Categories.Hazards.Add(new PreloadObject("Mill Trap", "mill_trap", ("Greymoor_06", "Greymoor_windmill_cog (1)/GameObject/dustpen_trap_shine0000"), null, null, HazardFixers.FixMillTrap).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards).WithRotationGroup(RotationGroup.All));
			Categories.Platforming.Add(new PreloadObject("Scarecraw", "scarecraw", ("Greymoor_03", "Weathervane States/Post Quest/Scarecraw")));
			Categories.Platforming.Add(new PreloadObject("Rag Balloon S", "greymoor_balloon_small", ("Greymoor_03", "greymoor_balloon_small (2)")));
			Categories.Platforming.Add(new PreloadObject("Rag Balloon M", "greymoor_balloon_mid", ("Greymoor_03", "greymoor_balloon_mid (1)")));
			Categories.Platforming.Add(new PreloadObject("Rag Balloon L", "greymoor_balloon_large", ("Greymoor_03", "greymoor_balloon_large")));
			Categories.Interactable.Add(new PreloadObject("Grey Gate", "grey_lever_gate", ("Greymoor_07", "grey_lever_gate (1)")).WithReceiverGroup(ReceiverGroup.CloseableGates).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloseableGates));
			Categories.Effects.Add(new PreloadObject("Rain Effect", "rain_effect", ("Greymoor_07", "Greymoor_Rain_Tiled_Set"), "Affects a large area.", null, MiscFixers.FixDecoration, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("rain", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations);
			AddSolid("Greymoor Platform 1", "moor_plat_1", ("Greymoor_03", "Black Thread States Thread Only Variant/Normal World/Strut Structure/Tilt Plat"), delegate(GameObject o)
			{
				for (int i = 4; i <= 6; i++)
				{
					((Component)o.transform.GetChild(1).GetChild(i)).gameObject.SetActive(false);
				}
			});
		}

		private static void AddWhitewardObjects()
		{
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Surgeon", "surgeon", ("Ward_09", "Sherma Rescue Scene/Activation Folder/Battle Scene/Wave 1/Song Pilgrim 02"), null, notSceneBundle: false, EnemyFixers.FixSurgeon).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Surgeon);
			AddEnemy("Mortician", "mortician", ("Ward_03", "Song Creeper (2)"));
			AddEnemy("Dreg Husk", "slasher", ("Ward_02", "Boss Scene Parent/Respawn Scene/Husks/Slasher 1"), null, notSceneBundle: false, EnemyFixers.FixDregHusk).DoFlipX();
			AddEnemy("Dregwheel", "slammer", ("Ward_02", "Boss Scene Parent/Respawn Scene/Husks/Slammer 1"), null, notSceneBundle: false, null, EnemyFixers.FixDregwheel).DoFlipX();
			Categories.Misc.Add(new PreloadObject("Coal Bucket", "barrel_03_opencoal", ("Ward_03", "brk_barrel_03_opencoal")));
			Categories.Abilities.Add(new PreloadObject("Silk Heart", "silk_heart", ("Ward_02", "Boss Scene Parent/Silk Heart"), null, delegate(GameObject o)
			{
				PlayMakerFSM fsm3 = FSMUtility.LocateMyFSM(o, "Control");
				fsm3.GetState("Memory?").AddAction(delegate
				{
					o.BroadcastEvent("OnActivate");
					fsm3.SendEvent("FINISHED");
				}, 0, everyFrame: false);
			}, null, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("silk_heart", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SilkHeart).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			Categories.Abilities.Add(new PreloadObject("Mask Shard", "mask_shard", ("Bone_East_LavaChallenge", "Heart Piece (1)"), null, delegate(GameObject o)
			{
				iTween.Init(o);
				PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(o, "Heart Container Control");
				fsm2.GetState("Pickup Disabled?").AddAction(delegate
				{
					PlayerData.instance.heartPieces = Math.Clamp(PlayerData.instance.heartPieces, 0, 3);
				}, 0, everyFrame: false);
				fsm2.GetState("Save Collected").AddAction(delegate
				{
					o.BroadcastEvent("OnActivate");
				}, -1, everyFrame: false);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.MaskAndSpool).WithReceiverGroup(ReceiverGroup.MaskAndSpool).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			Categories.Abilities.Add(new PreloadObject("Spool Fragment", "spool_fragment", ("Bone_11b", "Silk Spool"), null, delegate(GameObject o)
			{
				iTween.Init(o);
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(o, "Control");
				fsm.GetState("Pickup Disabled?").AddAction(delegate
				{
					PlayerData.instance.silkSpoolParts = Math.Clamp(PlayerData.instance.silkSpoolParts, 0, 1);
				}, 0, everyFrame: false);
				fsm.GetState("Save").AddAction(delegate
				{
					o.BroadcastEvent("OnActivate");
				}, -1, everyFrame: false);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.MaskAndSpool).WithReceiverGroup(ReceiverGroup.MaskAndSpool).WithBroadcasterGroup(BroadcasterGroup.Activatable));
		}

		private static void AddSlabObjects()
		{
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Expected O, but got Unknown
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Penitent", "penitent", ("Slab_15", "Slab Prisoner Leaper New"));
			AddEnemy("Puny Penitent", "puny_penitent", ("Slab_15", "Slab Prisoner Fly New"));
			AddEnemy("Scabfly", "scabfly", ("Slab_05", "Slab Fly Small"));
			AddEnemy("Guardfly", "guardfly", ("Slab_04", "Slab Fly Mid (2)"));
			AddEnemy("Wardenfly", "wardenfly", ("Slab_22", "Slab Fly Large"));
			Categories.Attacks.Add(new PreloadObject("Fly Spit", "fly_spit", ("localpoolprefabs_assets_areaslab", "Assets/Prefabs/Hornet Enemies/Slab Fly Glob.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Freshfly", "freshfly", ("Slab_16b", "Broodmother Scene Control/Broodmother Scene/Battle Scene Broodmother/Spawner Flies/Slab Fly Small Fresh"), null, notSceneBundle: false, null, EnemyFixers.FixFreshfly);
			AddEnemy("Broodmother", "broodmother", ("Slab_16b", "Broodmother Scene Control/Broodmother Scene/Battle Scene Broodmother/Wave 4/Slab Fly Broodmother"), null, notSceneBundle: false, null, EnemyFixers.FixBroodmother).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.Bosses);
			AddEnemy("Wardenfly Jailer", "slab_jailer", ("Bone_East_04c", "Scene Control/Slab Jailer Scene/Slab Fly Large Cage"), null, notSceneBundle: false, EnemyFixers.KeepActive, EnemyFixers.FixJailer).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Jailer).DoFlipX();
			AddEnemy("First Sinner", "first_sinner", ("Slab_10b", "Boss Scene/First Weaver"), null, notSceneBundle: false, delegate(GameObject o)
			{
				tk2dSpriteAnimator component2 = o.GetComponent<tk2dSpriteAnimator>();
				component2.defaultClipId = component2.GetClipIdByName("Idle");
			}, EnemyFixers.FixFirstSinner).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.Bosses);
			GameObject runeRage = new GameObject("[Architect] Rune Rage");
			runeRage.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)runeRage);
			Categories.Attacks.Add(new CustomObject("Rune Rage", "rune_rage", runeRage, "Appears when the 'Activate' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("rune_rage", (FilterMode)1)).WithReceiverGroup(ReceiverGroup.RuneBomb));
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_areaslab", "Assets/Prefabs/Heroes/Tools/First Weaver Bomb Blast.prefab", delegate(GameObject o)
			{
				bool activeSelf = o.activeSelf;
				o.SetActive(false);
				Object.Instantiate<GameObject>(o, runeRage.transform);
				if (activeSelf)
				{
					o.SetActive(true);
				}
			}, notSceneBundle: true));
			Categories.Interactable.Add(new PreloadObject("Slab Pressure Plate", "slab_pressure_plate", ("Slab_05", "spike_trap_slab_jail/pressure_plate"), null, InteractableFixers.FixSlabPlate).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			Categories.Hazards.Add(new PreloadObject("Slab Trap", "slab_trap", ("Slab_05", "spike_trap_slab_jail"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(1)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}));
			Categories.Interactable.Add(new PreloadObject("Slab Lever", "jail_lever", ("Slab_22", "slab_jail_lever"), null, InteractableFixers.FixLever).WithBroadcasterGroup(BroadcasterGroup.Levers).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Levers).WithRotationGroup(RotationGroup.Eight));
			Categories.Interactable.Add(new PreloadObject("Slab Gate", "jail_gate_door", ("Slab_05", "Jail Gate Door (2)"), null, delegate(GameObject o)
			{
				Gate component = o.GetComponent<Gate>();
				component.closeAnim = "Close";
				component.isClosed = true;
				component.ForceClose();
			}, EnemyFixers.KeepActive).WithReceiverGroup(ReceiverGroup.CloseableGates).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloseableGates));
			Categories.Hazards.Add(new PreloadObject("Slab Spike Ball", "slab_spike_ball", ("Slab_21", "slab_spike_ball"), "Hangs from a chain.", null, InteractableFixers.FixSpikeBall));
			Categories.Hazards.Add(new PreloadObject("Slab Spinning Blade", "slab_prob_blade", ("Slab_21", "trap_spinning_blade_S_bend_slab_jail (4)/prop_blade"), null, null, InteractableFixers.FixSlabBlade));
		}

		private static void AddPeakObjects()
		{
			//IL_0108: 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_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Mnemonid", "crystal_drifter", ("Peak_06", "Crystal Drifter"));
			AddEnemy("Mnemonord", "crystal_drifter_giant", ("Peak_06", "Crystal Drifter Giant"));
			AddEnemy("Driftlin", "peaks_drifter", ("Peak_05", "Peaks Drifter"));
			Categories.Platforming.Add(new PreloadObject("Gold Ring", "harpoon_ring", ("Peak_05", "chair_lift_ring/Harpoon Ring Citadel"), null, MiscFixers.FixRing, delegate(GameObject o)
			{
				Extensions.SetLocalPositionZ(o.transform, 0.01f);
			}).DoFlipX().WithBroadcasterGroup(BroadcasterGroup.HarpoonRings));
			Categories.Platforming.Add(new PreloadObject("Vertical Moving Ring", "harpoon_ring_v", ("Hang_08", "Harpoon Ring VerticalRide"), null, uiSprite: ResourceUtils.LoadSpriteResource("ring_up", (FilterMode)1), preloadAction: MiscFixers.FixRotation, postSpawnAction: MiscFixers.FixRing).DoFlipX().WithConfigGroup(Architect.Objects.Groups.ConfigGroup.VerticalRing).WithBroadcasterGroup(BroadcasterGroup.HarpoonRings));
			Categories.Platforming.Add(new PreloadObject("Horizontal Moving Ring", "harpoon_ring_h", ("Cog_08", "Harpoon Ring Rail Slider"), null, uiSprite: ResourceUtils.LoadSpriteResource("ring_side", (FilterMode)1), preloadAction: MiscFixers.FixRotation, postSpawnAction: MiscFixers.FixRing).DoFlipX()).WithBroadcasterGroup(BroadcasterGroup.HarpoonRings);
			Categories.Misc.Add(new PreloadObject("Coldshard", "snow_chunk", ("Bellway_Peak_02", "Snowflake Chunk (82)"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(3).GetChild(0)).gameObject.SetActive(false);
				o.RemoveComponent<RandomlyFlipScale>();
				((Behaviour)FSMUtility.LocateMyFSM(o, "Control")).enabled = true;
			}).WithRotationGroup(RotationGroup.All));
			Categories.Misc.Add(new PreloadObject("Floating Coldshard", "float_crystal", ("Peak_06", "Float Crystal (13)"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(0).GetChild(0)).gameObject.SetActive(false);
				o.RemoveComponent<RandomlyFlipScale>();
			}).WithRotationGroup(RotationGroup.All));
			Categories.Misc.Add(new PreloadObject("Weaver Heat Lamp S", "weaver_heat_lamp", ("Peak_05", "weaver_heat_lamp (2)/Lamp"), null, null, MiscFixers.FixLamp).WithRotationGroup(RotationGroup.Four).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Weaver Heat Lamp L", "weaver_heat_lamp_l", ("Bellway_Peak_02", "weaver lamp_roof heat large"), null, null, MiscFixers.FixBigLamp).WithRotationGroup(RotationGroup.Four).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Coal Lamp", "coal_lamp", ("Peak_05", "coal_lantern_jail_wall_mount/string_cap")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations));
			Categories.Platforming.Add(new PreloadObject("Slope Area", "slope_area", ("Peak_05", "Slide Surface (2)"), null, null, delegate(GameObject o)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				o.GetComponent<PolygonCollider2D>().points = (Vector2[])(object)new Vector2[4]
				{
					new Vector2(-2.5f, -2.5f),
					new Vector2(-2.5f, 2.5f),
					new Vector2(2.5f, 2.5f),
					new Vector2(2.5f, -2.5f)
				};
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("slope", (FilterMode)0, default(Vector4), 25.6f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Slope).WithRotationGroup(RotationGroup.All));
			Categories.Npcs.Add(new PreloadObject("Mask Maker NPC", "mask_maker_npc", ("Peak_Mask_Maker", "Peak Mask Maker"), null, MiscFixers.FixMaskMaker).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.MaskMaker).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Misc.Add(new PreloadObject("Fayforn (Ground)", "fayforn_npc", ("Peak_08b", "DJ Get Sequence/Fayforn Ground Sit NPC"), null, null, null, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("fayforn_preview", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Fayforn));
		}

		private static void AddBileObjects()
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: 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_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Bloatroach", "bloat_roach", ("Shadow_02", "Bloat Roach"), null, notSceneBundle: false, EnemyFixers.FixBloatroachPreload, EnemyFixers.FixBloatroach);
			AddEnemy("Miremite", "swamp_goomba", ("Shadow_02", "Black Thread States Thread Only Variant/Normal World/Swamp Goomba")).DoFlipX();
			AddEnemy("Swamp Squit", "swamp_mosquito", ("Shadow_04", "Swamp Mosquito (3)"));
			Categories.Platforming.Add(new PreloadObject("Water Area", "water_area", ("Shadow_04", "GameObject/Surface Water Region"), null, null, sprite: ResourceUtils.LoadSpriteResource("water", (FilterMode)0, default(Vector4), 25.6f), preloadAction: MiscFixers.FixWater).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Water));
			Categories.Misc.Add(new PreloadObject("Spa Area", "spa_area", ("Song_10", "Spa Region (1)"), null, null, sprite: ResourceUtils.LoadSpriteResource("spa", (FilterMode)0, default(Vector4), 25.6f), preloadAction: MiscFixers.FixSpaArea).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Stretchable));
			Categories.Effects.Add(new PreloadObject("Splash Area", "splash_effect", ("Hang_09", "Soft Waterfall Region"), null, null, delegate(GameObject o)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				BoxCollider2D component = o.GetComponent<BoxCollider2D>();
				component.size = new Vector2(5f, 5f);
				((Collider2D)component).offset = Vector2.zero;
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("splash", (FilterMode)0, default(Vector4), 25.6f)));
			Categories.Effects.Add(new PreloadObject("Flowing Water", "flowing_water_effect", ("Hang_09", "coral_river_chunk/river_top/Base"), null, null, delegate(GameObject o)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetRotation2D(o.transform, 0f);
				Extensions.SetScale2D(o.transform, new Vector2(3f, 3f));
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("water_flow", (FilterMode)0, default(Vector4), 215f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FlowingWater).WithRotationGroup(RotationGroup.All));
			Categories.Effects.Add(new PreloadObject("Waterfall A", "waterfall_effect", ("Hang_09", "coral_river_chunk/waterfall/Base"), null, null, delegate(GameObject o)
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(3)).gameObject.SetActive(false);
				Extensions.SetScale2D(o.transform, new Vector2(3f, 3f));
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("water_fall", (FilterMode)0, default(Vector4), 215f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FlowingWater));
			Categories.Effects.Add(new PreloadObject("Waterfall B", "waterfall_top", ("Memory_Coral_Tower", "Top (39)"), null, null, delegate(GameObject o)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetPositionZ(o.transform, 0.01f);
				o.transform.localScale = new Vector3(6f, 6f, 1f);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("water_fall_b", (FilterMode)0, default(Vector4), 215f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FlowingWater));
			Categories.Effects.Add(new PreloadObject("Waterfall C", "water_waterfall_tiled", ("Memory_Coral_Tower", "water_waterfall_tiled (2)"), null, null, delegate(GameObject o)
			{
				//IL_0007: 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)
				o.transform.localScale = Vector3.one;
				Extensions.SetPositionZ(o.transform, 0.01f);
				Extensions.SetLocalPositionY(o.transform.GetChild(0), 0f);
				Extensions.SetLocalPositionX(o.transform.GetChild(1), 0f);
				o.transform.GetChild(0).localScale = new Vector3(6f, 6f, 1f);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("water_fall_c", (FilterMode)0, default(Vector4), 35.83f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FlowingWater));
			Categories.Effects.Add(new PreloadObject("Waterfall D", "coral_river_tiled_thin_waterfall", ("Memory_Coral_Tower", "coral_river_tiled_thin_waterfall (13)"), null, null, delegate(GameObject o)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				o.transform.localScale = new Vector3(2f, 4f, 1f);
				o.transform.GetChild(0).localScale = Vector3.one;
				Extensions.SetPositionZ(o.transform, 0.01f);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("water_fall_d", (FilterMode)0, default(Vector4), 215f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FlowingWater));
			AddEnemy("Stilkin", "stilkin", ("Shadow_12", "Swamp Muckman All Control/Swamp Muckman (4)"), null, notSceneBundle: false, null, EnemyFixers.FixStilkin).WithBroadcasterGroup(BroadcasterGroup.Ambushers);
			AddEnemy("Stilkin Trapper", "stilkin_trapper", ("Shadow_12", "Swamp Muckman All Control/Swamp Muckman Tall Control/Activation Folder/Swamp Muckman Tall"), null, notSceneBundle: false, null, EnemyFixers.FixStilkinTrapper).WithBroadcasterGroup(BroadcasterGroup.Ambushers).DoFlipX();
			Categories.Attacks.Add(new PreloadObject("Stilkin Dart", "stilkin_dart", ("localpoolprefabs_assets_areaswamp", "Assets/Prefabs/Hornet Enemies/Swamp Muckman Dart.prefab"), null, null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Mothleaf Lagnia", "mothleaf", ("Shadow_26", "Swamp Drifter"));
			AddEnemy("Groal the Great", "groal", ("Shadow_18", "Battle Scene/Wave 6 - Boss/Swamp Shaman"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition, EnemyFixers.FixGroal).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.Groal);
			AddSolid("Bilewater Platform 1", "swamp_plat_1", ("Shadow_02", "plank_plat (4)"), MiscFixers.FixBilePlat);
			AddSolid("Bilewater Platform 2", "swamp_plat_2", ("Shadow_26", "gloom_lift_destroy/gloom_lift_set/gloom_plat_lift destroy"));
			Categories.Platforming.Add(new PreloadObject("Muck Pod", "swap_bounce_pod", ("Shadow_02", "Swamp Bounce Pod")).DoFlipX());
			Categories.Platforming.Add(new PreloadObject("Crumbling Moss", "moss_crumble_plat", ("Shadow_02", "moss_crumble_plat")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CrumblePlat));
			Categories.Misc.Add(new PreloadObject("Maggot Sack", "maggot_sack", ("Shadow_18", "maggot_sack_break (1)"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor));
			Categories.Hazards.Add(new PreloadObject("Stake Trap", "bilewater_trap", ("Shadow_10", "Swamp Stake Shooter Folder (1)/Swamp Stake Shooter"), null, delegate(GameObject o)
			{
				PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(o, "Control");
				fsm2.GetState("Fire").AddAction(delegate
				{
					fsm2.SetState("Idle");
				}, -1, everyFrame: false);
			}, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.006f);
			}).DoFlipX().WithRotationGroup(RotationGroup.All).WithReceiverGroup(ReceiverGroup.Trap));
			int terrainMask = LayerMask.GetMask(new string[1] { "Terrain" });
			Categories.Hazards.Add(new PreloadObject("Falling Spike Ball", "falling_spike_ball", ("Shadow_11", "stake_trap_spikeball_loose Scene/stake_trap_spikeball_loose"), null, delegate(GameObject o)
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(o, "Control");
				FsmState state2 = fsm.GetState("Roll Out");
				state2.DisableAction(6);
				state2.AddAction(delegate
				{
					fsm.SendEvent("NEXT");
				}, 6, everyFrame: false);
				FsmState state3 = fsm.GetState("Falling");
				state3.DisableAction(0);
				state3.AddAction(delegate
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0041: Unknown result type (might be due to invalid IL or missing references)
					if (RaycastHit2D.op_Implicit(Physics2D.Raycast(Vector2.op_Implicit(o.transform.position), Vector2.down, 1.5f * o.transform.localScale.y, terrainMask)))
					{
						fsm.SendEvent("NEXT");
					}
				}, 0, everyFrame: true);
			}, delegate(GameObject o)
			{
				o.RemoveComponent<PersistentBoolItem>();
			}).WithReceiverGroup(ReceiverGroup.Trap).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards));
			Categories.Hazards.Add(new PreloadObject("Spike Ball", "swing_trap_small", ("Shadow_10", "Spike Ball Folder/stake_trap_swing"), null, null, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 3.65f);
				((Component)o.transform.GetChild(0).GetChild(1)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1).GetChild(0).GetChild(1)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1).GetChild(0).GetChild(2)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1).GetChild(1).GetChild(1)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1).GetChild(1).GetChild(2)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1).GetChild(1)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithRotationGroup(RotationGroup.All).WithReceiverGroup(ReceiverGroup.Trap).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards));
			Categories.Hazards.Add(new PreloadObject("Groal's Spike Ball", "swing_trap_spike", ("Shadow_18", "Battle Scene/stake_trap_swing_repeater"), "Only has collision when swinging.", null, HazardFixers.FixSpikeBall).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards).WithReceiverGroup(ReceiverGroup.SpikeBall));
			Categories.Attacks.Add(new PreloadObject("Groal's Vengeful Spirit", "groal_fireball", ("localpoolprefabs_assets_areaswamp.bundle", "Assets/Prefabs/Hornet Enemies/Swamp Shaman Fireball.prefab"), null, delegate(GameObject o)
			{
				Extensions.SetScaleX(o.transform, 0f - Extensions.GetScaleX(o.transform));
				Rigidbody2D rb2d = o.GetComponent<Rigidbody2D>();
				FsmState state = FSMUtility.LocateMyFSM(o, "Control").GetState("Fly");
				state.DisableAction(2);
				state.AddAction(delegate
				{
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_003b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Unknown result type (might be due to invalid IL or missing references)
					//IL_0045: Unknown result type (might be due to invalid IL or missing references)
					rb2d.linearVelocity = Vector2.op_Implicit(o.transform.rotation * (new Vector3(-28f, 0f, 0f) * Extensions.GetScaleX(o.transform)));
				}, 0, everyFrame: true);
			}, null, preview: false, notSceneBundle: true).WithRotationGroup(RotationGroup.All));
			Categories.Interactable.Add(new PreloadObject("Wooden Gate", "bile_gate", ("Shadow_18", "Battle Scene/Gates/Battle Gate Swamp")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloseableGates).WithReceiverGroup(ReceiverGroup.BattleGate).WithRotationGroup(RotationGroup.Four));
			Categories.Misc.Add(new PreloadObject("Body Sack", "body_sack", ("Shadow_27", "Breakable Hang Sack 2"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BodySack));
		}

		private static void AddMistObjects()
		{
			AddEnemy("Wraith", "wraith", ("Dust_Maze_01", "Wraith"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition, delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").GetState("Init").DisableAction(2);
			});
			AddEnemy("Phantom", "phantom", ("Organ_01", "Boss Scene/Phantom"), null, notSceneBundle: false, null, EnemyFixers.FixPhantom).WithBroadcasterGroup(BroadcasterGroup.SlamEnemies).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Slowdown);
			Categories.Hazards.Add(new PreloadObject("Pressure Plate Trap", "dust_trap_spike_plate", ("Dust_Maze_01", "Mist Maze Controller/Trap Sets/Trap Set/Dust Trap Spike Plate")));
			Categories.Hazards.Add(new PreloadObject("Falling Spike Trap", "dust_trap_spike_dropper", ("Dust_Maze_01", "Mist Maze Controller/Trap Sets/Trap Set/Dust Trap Spike Dropper")).DoFlipX());
			Categories.Hazards.Add(new PreloadObject("Mite Trap", "mite_trap", ("Dust_Maze_01", "Mist Maze Controller/Trap Sets/Trap Set/Mite Trap")).DoFlipX());
			Categories.Hazards.Add(new PreloadObject("Organ Spikes", "organ_spikes", ("Organ_01", "Spike (7)")).WithRotationGroup(RotationGroup.Four));
			AddSolid("Organ Platform 1", "organ_plat_1", ("Organ_01", "Organ_outer__0012_balcony_side_plat"));
			AddSolid("Organ Platform 2", "organ_plat_2", ("Organ_01", "GameObject (58)/metal_bridge (2)"), delegate(GameObject o)
			{
				for (int i = 1; i <= 4; i++)
				{
					((Component)o.transform.GetChild(i)).gameObject.SetActive(false);
				}
			});
			AddSolid("Organ Platform 3", "organ_plat_3", ("Organ_01", "organ_lift_broken_drop/lift_bottom_broken"), delegate(GameObject o)
			{
				((Component)o.transform.GetChild(3)).gameObject.SetActive(false);
			});
			Categories.Interactable.Add(new PreloadObject("Ambient Silkfly", "silkfly_ambient", ("Mosstown_02", "Silkfly Ambient")));
			Categories.Interactable.Add(new PreloadObject("Mist Silkfly", "silkfly", ("localpoolprefabs_assets_areadustmaze", "Assets/Prefabs/Hornet Enemies/Silkfly Mistmaze.prefab"), null, MiscFixers.FixSilkfly, null, preview: false, notSceneBundle: true).WithBroadcasterGroup(BroadcasterGroup.Activatable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Silkfly).WithReceiverGroup(ReceiverGroup.Silkfly));
		}

		private static void AddStepsObjects()
		{
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			Categories.Platforming.Add(new PreloadObject("Grey Ring", "harpoon_ring_pinstress", ("Coral_34", "Harpoon Ring Pinstress Rope (4)"), null, MiscFixers.FixRing).DoFlipX().WithBroadcasterGroup(BroadcasterGroup.HarpoonRings));
			Categories.Platforming.Add(new PreloadObject("Bell of Judgement", "hang_bell", ("Coral_32", "shell_plat_hang_bell (4)"), null, null, MiscFixers.FixBellSprite).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bell));
			Categories.Platforming.Add(new PreloadObject("Bell of the Judged", "hang_bell_citadel", ("Song_20b", "sc_plat_hang_bell (5)"), null, null, MiscFixers.FixBellSprite).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bell));
			AddEnemy("Squirm", "squirm", ("Coral_36", "Judge Child (1)"), null, notSceneBundle: false, null, EnemyFixers.FixSquirm).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Squirm);
			AddEnemy("Judge", "judge", ("Coral_32", "Black Thread States/Normal World/Coral Judge (3)"), null, notSceneBundle: false, MiscFixers.AddComponent<EnemyFixers.Judge>, delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").GetState("Shield Block").AddAction(delegate
				{
					o.BroadcastEvent("OnBlock");
				}, 0, everyFrame: false);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Judge).WithBroadcasterGroup(BroadcasterGroup.Judge).WithReceiverGroup(ReceiverGroup.Wakeable);
			AddEnemy("Last Judge", "last_judge", ("Coral_Judge_Arena", "Boss Scene/Last Judge"), null, notSceneBundle: false, null, EnemyFixers.FixLastJudge).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LastJudge).WithBroadcasterGroup(BroadcasterGroup.LastJudge).WithOutputGroup(OutputGroup.LastJudge);
			Categories.Misc.Add(new PreloadObject("Judge Statue", "judge_statue", ("Coral_32", "fossil_judge_break_leanRight"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Effects.Add(new PreloadObject("Sandstorm Effect", "sand_effect", ("Coral_32", "blown_sand_tiled_set"), null, null, MiscFixers.FixDecoration, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("sand", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations);
			Categories.Hazards.Add(new PreloadObject("Sandcarvers", "sandcarver_group", ("Coral_11", "Sand Centipede Attacker (10)"), null, HazardFixers.FixCarvers, delegate(GameObject o)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				o.GetComponent<SpriteRenderer>().color = Color.white;
				Extensions.SetPositionZ(o.transform, -0.0054f);
				Extensions.SetRotation2D(o.transform, 0f);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Sandcarver));
			Categories.Npcs.Add(new PreloadObject("Steel Seer Zi", "steel_seer", ("Coral_37", "Room_States/Steel/Steel Sentinel"), null, null, MiscFixers.FixZi).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SeerZi).WithBroadcasterGroup(BroadcasterGroup.Npcs));
		}

		private static void AddMiscObjects()
		{
			//IL_0072: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_082f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0979: Unknown result type (might be due to invalid IL or missing references)
			//IL_097f: Unknown result type (might be due to invalid IL or missing references)
			//IL_14c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_14c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_14da: Unknown result type (might be due to invalid IL or missing references)
			//IL_14e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_160b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1611: Unknown result type (might be due to invalid IL or missing references)
			//IL_18df: Unknown result type (might be due to invalid IL or missing references)
			//IL_18e9: Expected O, but got Unknown
			//IL_1926: Unknown result type (might be due to invalid IL or missing references)
			//IL_192c: Unknown result type (might be due to invalid IL or missing references)
			//IL_19c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_19ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a44: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a4a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ad8: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ade: Unknown result type (might be due to invalid IL or missing references)
			Categories.Effects.Add(new PreloadObject("Blur Plane", "blur_plane", ("Belltown", "BlurPlane"), "Having multiple blur planes together can cause issues.\nIt is recommended to disable the vanilla BlurPlane when using a custom one.\n\nBlur Planes can sometimes cause unusual distortion,\nif this happens try adjusting the Blur Plane's scale.", delegate(GameObject o)
			{
				//IL_0007: 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)
				Transform transform = o.transform;
				transform.localScale *= 1000000f;
			}, delegate(GameObject o)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				o.transform.localScale = new Vector3(100f, 100f, 1f);
			}, preview: true, notSceneBundle: false, ResourceUtils.LoadSpriteResource("blur", (FilterMode)1, default(Vector4), 3775f))).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BlurPlane);
			GameObject threadEffect = new GameObject("[Architect] Thread Effect");
			threadEffect.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)threadEffect);
			Categories.Effects.Add(new CustomObject("Thread Effect", "thread_effect", threadEffect, "Appears when the 'Activate' trigger is run.", MiscFixers.FixThreadEffect, preview: false, ResourceUtils.LoadSpriteResource("thread", (FilterMode)1, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.ThreadEffect).DoFlipX());
			PreloadManager.RegisterPreload(new BasicPreload("globalpoolprefabs_assets_all", "Assets/Prefabs/Silk Possession Obj.prefab", delegate(GameObject o)
			{
				GameObject val8 = Object.Instantiate<GameObject>(o, threadEffect.transform);
				val8.RemoveComponent<DeactivateIfPlayerdataTrue>();
				((Component)val8.transform.GetChild(0)).gameObject.AddComponent<MiscFixers.KeepInactive>();
				val8.SetActive(true);
			}, notSceneBundle: true));
			GameObject val = new GameObject("[Architect] Black Thread Effect");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			Categories.Effects.Add(new CustomObject("Black Thread Effect", "black_thread_effect", val, "Appears when the 'Activate' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("black_thread", (FilterMode)1, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.RuneBomb));
			Object.Instantiate<GameObject>(Effects.BlackThreadEnemyStartEffect, val.transform).transform.localPosition = Vector3.zero;
			Categories.Misc.Add(new PreloadObject("Bone Chest", "bone_chest", ("Bone_19", "Bone Chest"), null, MiscFixers.FixChest).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Chest).WithRotationGroup(RotationGroup.Four).DoFlipX());
			Categories.Misc.Add(new PreloadObject("Citadel Chest", "song_chest", ("Song_03", "Chest Scene/Chest"), null, MiscFixers.FixChest).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Chest).WithRotationGroup(RotationGroup.Four).DoFlipX());
			Categories.Misc.Add(new PreloadObject("Large Citadel Chest", "docks_chest", ("Dock_06_Church", "Black Thread States Thread Only Variant/Normal World/City Shard Chest"), null, MiscFixers.FixChest).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Chest).WithRotationGroup(RotationGroup.Four).DoFlipX());
			Categories.Misc.Add(new PreloadObject("Breakable Wall A", "breakable_wall_2", ("Bone_19", "Breakable Wall"), null, MiscFixers.FixBreakableWall, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(0)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
			}).WithRotationGroup(RotationGroup.Four).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableWall).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable));
			Categories.Misc.Add(new PreloadObject("Breakable Wall B", "breakable_wall", ("Aqueduct_03", "Breakable Wall"), null, MiscFixers.FixBreakableWall, delegate(GameObject o)
			{
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				((Component)o.transform.GetChild(0)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
				BoxCollider2D component3 = o.GetComponent<BoxCollider2D>();
				((Collider2D)component3).offset = Vector2.zero;
				component3.size = new Vector2(2.25f, 4.25f);
			}).WithRotationGroup(RotationGroup.Four).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableWall).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable));
			Categories.Misc.Add(new PreloadObject("Breakable Window", "breakable_window", ("Song_20", "Breakable Window"), null, MiscFixers.FixBreakableWindow, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(2).GetChild(2)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("window", (FilterMode)1, default(Vector4), 70f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable).WithRotationGroup(RotationGroup.Four)
				.DoFlipX());
			Categories.Misc.Add(new PreloadObject("Rosary Shrine", "rosary_shrine_small", ("Bonetown", "rosary_shrine_small"), null, null, MiscFixers.FocusFirstChild));
			Categories.Misc.Add(new PreloadObject("Rosary Bell", "rosary_bell", ("Belltown_basement_03", "rosary_cache_bell_ground"), null, null, delegate(GameObject o)
			{
				o.transform.GetChild(1).GetChild(3).SetAsFirstSibling();
			}));
			Categories.Misc.AddStart(new PreloadObject("Toll Bench", "toll_bench", ("Under_08", "Understore Toll Bench (2)"), null, preloadAction: MiscFixers.FixTollBench, postSpawnAction: MiscFixers.AddBenchEvent, preview: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Benches).WithBroadcasterGroup(BroadcasterGroup.Benches));
			Categories.Misc.AddStart(new PreloadObject("Full Bell Bench", "bell_bench_full", ("Bone_East_15", "bell_bench"), null, delegate(GameObject o)
			{
				MiscFixers.AddBenchEvent(o);
				Transform obj = o.transform.Find("bell_toll_machine");
				((Object)obj).name = ((Object)obj).name + ((Object)o).name;
			}, delegate(GameObject o)
			{
				SpriteRenderer[] componentsInChildren3 = o.GetComponentsInChildren<SpriteRenderer>();
				foreach (SpriteRenderer val7 in componentsInChildren3)
				{
					val7.maskInteraction = (SpriteMaskInteraction)0;
				}
				((Component)o.transform.Find("frame")).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FullBellBench).WithBroadcasterGroup(BroadcasterGroup.Benches));
			Categories.Misc.AddStart(new PreloadObject("Bell Bench", "bell_bench", ("Bone_East_15", "bell_bench/RestBench"), null, preloadAction: MiscFixers.FixBench, postSpawnAction: MiscFixers.AddBenchEvent, preview: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BellBench).WithBroadcasterGroup(BroadcasterGroup.Benches));
			Categories.Effects.Add(new PreloadObject("Environment Region", "enviro_region", ("Bone_East_15", "bell_bench/Enviro Region Simple"), "Determines the environment,\nwhich controls things like ground particles and walking sounds.", null, delegate(GameObject o)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				o.transform.localScale = new Vector3(2f, 2f, 2f);
				BoxCollider2D component2 = o.GetComponent<BoxCollider2D>();
				((Collider2D)component2).offset = Vector2.zero;
				component2.size = Vector2.one;
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("environment_region", (FilterMode)1, default(Vector4), 200f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.EnviroRegion));
			Categories.Misc.AddStart(new PreloadObject("Bed", "bellhome_bed", ("Belltown_Room_Spare", "furnishings/bed/RestBench"), null, preloadAction: MiscFixers.FixBench, postSpawnAction: MiscFixers.AddBenchEvent, preview: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Benches).WithBroadcasterGroup(BroadcasterGroup.Benches));
			Categories.Interactable.Add(new PreloadObject("Toll Machine", "rosary_toll", ("Hang_06_bank", "rosary_cannon/Art/Rosary Cannon Scene/rosary_string_machine"), null, MiscFixers.FixToll).WithBroadcasterGroup(BroadcasterGroup.Toll).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Toll));
			Categories.Effects.Add(new PreloadObject("Reflection Effect", "mirror_effect", ("Hang_06b", "new_scene/Reflection_surface"), "Reflects objects above itself, can be configured\nin the same way as the Custom PNG for custom mirror shapes.", null, MiscFixers.FixSpecialPngs, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("reflection", (FilterMode)1, default(Vector4), 155f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Mirror).WithRotationGroup(RotationGroup.All));
			Categories.Effects.Add(new PreloadObject("Silhouette Effect", "silhouette_effect", ("Shadow_02", "Shakra Trail Quest Parent/Active/Tracking Trail (2)/Silhouettes Parent/Silhoutte"), "Silhouette effect from tracking, can be configured\nin the same way as the Custom PNG for custom shapes.", null, MiscFixers.FixSpecialPngs, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("silhouette", (FilterMode)1, default(Vector4), 155f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PhysicalPng).WithRotationGroup(RotationGroup.All));
			Categories.Effects.Add(new PreloadObject("Vignette Cutout Effect", "vignette_cutout_effect", ("Belltown", "Vignette Cutout (3)"), "Cuts out part of the vignette, can be used to make areas visible in darkness.", null, MiscFixers.FixSpecialPngs).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Png).WithRotationGroup(RotationGroup.All));
			Categories.Effects.Add(new PreloadObject("Memory Silk Effect", "memory_silk_effect", ("Coral_Tower_01", "Memory Group/before/thread_memory/thread_memory_starter/strand1/strandbacking (1)"), "Memory Silk effect from memory entrances, can be configured\nin the same way as the Custom PNG for custom shapes.", null, MiscFixers.FixSpecialPngs, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("memory", (FilterMode)1, default(Vector4), 155f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PhysicalPng).WithRotationGroup(RotationGroup.All));
			Categories.Effects.Add(new PreloadObject("Sway Effect", "sway_effect", ("Tut_02", "green_grass_tri (6)"), null, null, delegate(GameObject o)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				o.RemoveComponent<GrassCut>();
				((Component)o.transform.GetChild(0)).gameObject.AddComponent<PngObject>().ignoreGlow = true;
				o.transform.GetChild(0).localPosition = Vector3.zero;
				Extensions.SetPositionZ(o.transform, -0.1f);
				Extensions.SetRotation2D(o.transform, 0f);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Sway).WithRotationGroup(RotationGroup.All));
			Categories.Npcs.Add(new PreloadObject("Gilly NPC", "gilly_npc", ("Ant_17", "Gilly"), null, MiscFixers.FixGilly).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Npcs.Add(new PreloadObject("Wandering Seth NPC", "seth_npc", ("Coral_10", "Seth Stand NPC"), null, MiscFixers.FixSeth).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Npcs.Add(new PreloadObject("Garmond and Zaza NPC (Ally)", "garmond_zaza", ("Song_17", "Garmond Fight Scene/Garmond Fighter"), null, MiscFixers.FixGarmond).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			AddEnemy("Garmond and Zaza (Boss)", "garmond_zaza_boss", ("Library_09", "Black Thread States/Normal World/Scene Control/Garmond Scene/Garmond Fighter"), null, notSceneBundle: false, delegate(GameObject o)
			{
				tk2dSpriteAnimator component = o.GetComponent<tk2dSpriteAnimator>();
				component.defaultClipId = component.GetClipIdByName("Roar");
			}, MiscFixers.FixGarmondBoss).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.GarmondBoss).WithBroadcasterGroup(BroadcasterGroup.Bosses);
			AddEnemy("Lost Garmond", "lost_garmond", ("Coral_33", "Black Thread States/Black Thread World/Garmond Scenes/Garmond Black Threaded Scene/Garmond Black Threaded Fighter"), null, notSceneBundle: false, EnemyFixers.FixLostGarmondPreload, EnemyFixers.FixLostGarmond).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.Bosses);
			Categories.Misc.Add(new PreloadObject("Shakra Ring", "mapper_ring", ("Shadow_02", "Mapper/Mapper_ambient_rings/rings/mapper extra rings/mapper rings/Mapper_Ring_world (3)"), null, null, MiscFixers.MarkRing).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.MapperRing).WithBroadcasterGroup(BroadcasterGroup.MapperRing).WithReceiverGroup(ReceiverGroup.MapperRing)
				.WithInputGroup(InputGroup.Velocity));
			Categories.Misc.Add(new PreloadObject("Silk Spool", "silk_spool_take", ("Hang_01", "Thread Spinner")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SilkSpool));
			Categories.Interactable.Add(new PreloadObject("Needolin Gate", "weaver_gate", ("Weave_04", "top set/Song_Gate_set (2)"), null, null, delegate(GameObject o)
			{
				Extensions.SetLocalPositionZ(o.transform, 3.7316f);
				for (int l = 3; l <= 16; l++)
				{
					((Component)o.transform.GetChild(l)).gameObject.SetActive(false);
				}
				((Component)o.transform.GetChild(18)).gameObject.SetActive(false);
				for (int m = 20; m <= 24; m++)
				{
					((Component)o.transform.GetChild(m)).gameObject.SetActive(false);
				}
				((Component)o.transform.GetChild(31)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(32)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(19)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.NeedolinGate));
			Categories.Interactable.Add(new PreloadObject("Weaver Lift", "weaver_teleporter", ("Weave_02", "Group/weaver_lift_mid"), null, null, MiscFixers.FixWeaverLift).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Teleporter).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			AddEnemy("Servitor Ignim", "servitor_small", ("Weave_04", "Weaver Servitor (2)"), null, notSceneBundle: false, EnemyFixers.FixServitorIgnim);
			AddEnemy("Servitor Boran", "servitor_large", ("Peak_04d", "Weaver Servitor Large"), null, notSceneBundle: false, EnemyFixers.FixServitorBoran, delegate(GameObject o)
			{
				bool valid = false;
				Rigidbody2D rb2d = o.GetComponent<Rigidbody2D>();
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(o, "Control");
				fsm.GetState("Roll Away").AddAction(Mark, -1, everyFrame: false);
				fsm.GetState("Roll Away").AddAction(Correct, -1, everyFrame: true);
				fsm.GetState("Roll Toward").AddAction(Mark, -1, everyFrame: false);
				fsm.GetState("Roll Toward").AddAction(Correct, -1, everyFrame: true);
				void Correct()
				{
					if (valid)
					{
						valid = false;
					}
					else if (rb2d.linearVelocityX == 0f)
					{
						fsm.SendEvent("END");
					}
				}
				void Mark()
				{
					valid = true;
				}
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Boran);
			Categories.Attacks.Add(new PreloadObject("Servitor Blast", "servitor_blast", ("Peak_04d", "Weaver Servitor Large"), "Activates when the 'Fire' trigger is run, just the blast effect", delegate(GameObject o)
			{
				o.RemoveComponent<HealthManager>();
				o.RemoveComponentsInChildren<tk2dSpriteAnimator>();
				o.RemoveComponentsInChildren<tk2dSprite>();
				o.RemoveComponentsInChildren<MeshRenderer>();
				o.RemoveComponentsInChildren<Rigidbody2D>();
				o.RemoveComponent<BoxCollider2D>();
				((Component)o.transform.Find("Head Collider")).gameObject.RemoveComponent<CircleCollider2D>();
				PlayMakerFSM val6 = FSMUtility.LocateMyFSM(o, "Control");
				FsmState state = val6.GetState("Shoot");
				state.DisableAction(8);
				state.DisableAction(9);
				val6.fsm.startState = "Shoot Recover";
				FsmState state2 = val6.GetState("Shoot Recover");
				for (int k = 0; k <= 19; k++)
				{
					state2.DisableAction(k);
				}
				state2.transitions = Array.Empty<FsmTransition>();
			}).WithRotationGroup(RotationGroup.All).WithReceiverGroup(ReceiverGroup.Blast).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Damager));
			Categories.Interactable.Add(new PreloadObject("Silk Lever", "silk_lever", ("Weave_12", "weaver_lift_power_chamber/switches/Lever_Left"), null, null, InteractableFixers.FixSilkLever).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SilkLever).WithBroadcasterGroup(BroadcasterGroup.Levers).WithRotationGroup(RotationGroup.Eight));
			Categories.Misc.Add(new PreloadObject("Silkcatcher", "silkcatcher_plant", ("Ant_04", "Silkcatcher Plant")));
			Categories.Misc.Add(new PreloadObject("Silkdew", "silkcatcher_dew", ("Clover_06", "Group/Clover_Silk_Pod")));
			Categories.Interactable.Add(new PreloadObject("Shakra Summon Pole", "mapper_pole", ("Greymoor_08_mapper", "Mapper Call Pole"), null, InteractableFixers.FixShakraPole).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			AddEnemy("Shakra (Boss)", "shakra_boss", ("Greymoor_08_mapper", "Mapper Spar NPC"), null, notSceneBundle: false, null, EnemyFixers.FixShakra).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ShakraBoss);
			Categories.Npcs.Add(new PreloadObject("Shakra NPC (Ally)", "shakra", ("Shellwood_01", "Black Thread States/Black Thread World/Shakra Guard Scene/Scene Folder/Mapper StandGuard NPC"), null, MiscFixers.FixShakra).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Shakra).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Misc.Add(new PreloadObject("Shakra Lamp", "shakra_lamp", ("Belltown", "Mapper Control/Mapper Scenery/Mapper_lamp"), null, null, delegate(GameObject o)
			{
				((Object)o.transform.GetChild(0).GetChild(0).GetChild(0)).name = "[Architect] Lamp Part";
				EnemyFixers.KeepActive(o);
			}));
			Categories.Npcs.Add(new PreloadObject("Second Sentinel NPC (Ally)", "second_sentinel_ally", ("Song_25", "Song Knight Control/Song Knight Present/Song Knight BattleEncounter"), null, MiscFixers.FixSecondSentinelAlly));
			AddEnemy("Second Sentinel (Boss)", "second_sentinel_boss", ("Hang_17b", "Boss Scene - To Additive Load/Song Knight"), null, notSceneBundle: false, null, EnemyFixers.FixSecondSentinelBoss).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).DoFlipX();
			Categories.Npcs.Add(new PreloadObject("Pilgrim Preacher", "pilgrim_preacher", ("Song_Enclave", "Black Thread States/Normal World/Enclave States/States/Level 1/Enclave Simple NPC Tall"), null, null, MiscFixers.FixSongclavePilgrim).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Npcs.Add(new PreloadObject("Humble Pilgrim", "humble_pilgrim", ("Song_Enclave", "Black Thread States/Normal World/Enclave States/States/Level 2/Enclave Simple NPC Short Horned"), null, null, MiscFixers.FixSongclavePilgrim).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Npcs.Add(new PreloadObject("Dejected Pilgrim", "dejected_pilgrim", ("Song_Enclave", "Black Thread States/Black Thread World/Enclave Act 3 basic talk NPC/Present/Enclave Simple NPC Standard"), null, null, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.005f);
				((Component)o.transform.GetChild(4)).gameObject.SetActive(false);
				MiscFixers.FixSongclavePilgrim(o);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Npcs.Add(new PreloadObject("Worried Pilgrim", "worried_pilgrim", ("Song_Enclave", "Black Thread States/Black Thread World/Enclave Simple NPC Large"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(2)).gameObject.SetActive(false);
				MiscFixers.FixSongclavePilgrim(o);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Npcs.Add(new PreloadObject("Scared Pilgrim", "scared_pilgrim", ("Song_Enclave", "Black Thread States/Normal World/Enclave States/States/Level 1/Enclave Pilgrim Small"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(4)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(5)).gameObject.SetActive(false);
				MiscFixers.FixSongclavePilgrim(o);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Npcs.Add(new PreloadObject("Quiet Pilgrim", "quiet_pilgrim", ("Bonetown", "Black Thread States/Normal World/Generic Pilgrim Control/Generic Pilgrim Round"), null, MiscFixers.FixQuietPilgrim).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Npcs.Add(new PreloadObject("Caretaker NPC", "caretaker", ("Song_Enclave", "Black Thread States/Normal World/Enclave States/States/Level 1/Enclave Caretaker"), null, null, MiscFixers.FixCaretaker).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Caretaker).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Npcs.Add(new PreloadObject("Sherma NPC", "sherma_1", ("Song_Enclave", "Black Thread States/Normal World/Enclave States/States/Level 2/Sherma Enclave NPC"), null, null, MiscFixers.FixSherma).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Sherma).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Npcs.Add(new PreloadObject("Caretaker Sherma NPC", "sherma_2", ("Song_Enclave", "Black Thread States/Black Thread World/Enclave Act 3/Sherma Caretaker"), null, null, MiscFixers.FixShermaCaretaker).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Platforming.Add(new PreloadObject("Updraft", "updraft_region", ("Ant_19", "Updraft Region (1)"), null, null, MiscFixers.FixUpdraft, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("updraft", (FilterMode)1, default(Vector4), 112f), ResourceUtils.LoadSpriteResource("updraft_ui", (FilterMode)1)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Updraft).WithRotateAction(MiscFixers.DelayRotation));
			AddEnemy("Snitchfly", "snitchfly", ("Bonetown", "Black Thread States/Black Thread World/Thief Scene/Rosary Thief Group/Rosary Thief"), null, notSceneBundle: false, null, delegate(GameObject o)
			{
				((Behaviour)FSMUtility.LocateMyFSM(o, "Rummage Voice")).enabled = false;
				FSMUtility.LocateMyFSM(o, "Control").GetState("Left").AddAction(delegate
				{
					o.BroadcastEvent("OnFlee");
				}, 0, everyFrame: false);
			}).WithBroadcasterGroup(BroadcasterGroup.Snitchfly).DoFlipX();
			AddEnemy("Summoned Saviour", "summoned_saviour", ("Bone_Steel_Servant", "Steel Servant Scene/Battle Scene/Wave 1/Abyss Mass"), null, notSceneBundle: false, null, EnemyFixers.FixSummonedSaviour).WithBroadcasterGroup(BroadcasterGroup.Bosses).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).DoFlipX();
			Categories.Effects.Add(new PreloadObject("Black Thread Strand", "black_thread_strand", ("Song_19_Entrance", "Black Thread States/Black Thread World/black_thread_strand"), null, null, MiscFixers.FixBlackStrand, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("black_thread_strand", (FilterMode)1, default(Vector4), 75.5f))).DoIgnoreScale().WithRotationGroup(RotationGroup.All)
				.WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BlackStrand);
			Categories.Misc.Add(new PreloadObject("Greymoor Lamp", "greymoor_lamp", ("Greymoor_03", "break_grey_lamp_dual_twist (1)"), null, MiscFixers.FixBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithRotationGroup(RotationGroup.Four).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Vaults Lamp", "vault_lamp", ("Library_04", "library_lamp_stand (1)"), null, MiscFixers.FixBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithRotationGroup(RotationGroup.Four).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Vaults Wall Lamp", "vault_w_lamp", ("Library_04", "library_lamp_wall (2)"), null, MiscFixers.FixBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithRotationGroup(RotationGroup.Four).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Citadel Lamp", "citadel_lamp", ("Coral_10", "Black Thread States/Normal World/Hornet_way_pole_harp (9)"), null, MiscFixers.FixBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithRotationGroup(RotationGroup.Four).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Verdania Lamp", "verdania_lamp", ("Clover_04b", "break_grey_lamp_harp"), null, MiscFixers.FixBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithRotationGroup(RotationGroup.Four).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Petrified Pilgrim 1", "pilgrim_petrified_1", ("Coral_10", "pilgrim_fossil_break_larvae (4)"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Petrified Pilgrim 2", "pilgrim_petrified_2", ("Coral_10", "pilgrim_fossil_break_curved_horn"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			GameObject explosion = new GameObject("[Architect] Explosion");
			explosion.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)explosion);
			Categories.Attacks.Add(new CustomObject("Explosion", "explosion", explosion, "Appears when the 'Activate' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("explosion", (FilterMode)1, default(Vector4), 82f)).WithReceiverGroup(ReceiverGroup.RuneBomb).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Damager));
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_shared.bundle", "Assets/Prefabs/Enemies/Generic Attacks/Gas Explosion Recycle M.prefab", delegate(GameObject o)
			{
				bool activeSelf = o.activeSelf;
				o.SetActive(false);
				Object.Instantiate<GameObject>(o, explosion.transform);
				if (activeSelf)
				{
					o.SetActive(true);
				}
			}, notSceneBundle: true));
			Categories.Interactable.Add(new PreloadObject("Bind Source (Stab)", "bind_source", ("Greymoor_20c", "Crest Get Shrine"), null, InteractableFixers.FixBindSource, null, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("bind_source", (FilterMode)1, default(Vector4), 33f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BindSource).WithReceiverGroup(ReceiverGroup.BindSource).WithBroadcasterGroup(BroadcasterGroup.BindSourceStab));
			Categories.Interactable.Add(new PreloadObject("Bind Source (Stand)", "bind_source_stand", ("Shellwood_10", "Ability Scene (1)/Shrine Weaver Ability"), null, InteractableFixers.FixBindSourceStand, null, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("bind_source", (FilterMode)1, default(Vector4), 33f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Dialogue).WithBroadcasterGroup(BroadcasterGroup.BindSourceStand));
			Categories.Enemies.Add(new PreloadObject("Void Mass", "void_mass_citadel", ("Song_15", "Black Thread States/Black Thread World/Black_Thread_Core_Citadel"), null, EnemyFixers.KeepActive, delegate(GameObject o)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				o.transform.rotation = Quaternion.Euler(0f, 0f, -15f);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("void_mass", (FilterMode)1, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.Enemies).WithBroadcasterGroup(BroadcasterGroup.Enemies).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Enemies)
				.WithOutputGroup(OutputGroup.Enemies)
				.WithRotationGroup(RotationGroup.All));
			Categories.Platforming.Add(new PreloadObject("Small Bell", "bell_s", ("Bone_01c", "bell_bench/frame/small_bell Parent"), null, delegate(GameObject o)
			{
				PlayMakerFSM val5 = FSMUtility.LocateMyFSM(((Component)o.transform.GetChild(1)).gameObject, "interactive_bell");
				val5.fsmTemplate = null;
				val5.GetState("Apply Force").AddAction(delegate
				{
					o.BroadcastEvent("OnHit");
				}, 0, everyFrame: false);
			}, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, -0.114f);
				SpriteRenderer[] componentsInChildren2 = o.GetComponentsInChildren<SpriteRenderer>();
				foreach (SpriteRenderer val4 in componentsInChildren2)
				{
					val4.maskInteraction = (SpriteMaskInteraction)0;
				}
			})).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations).WithBroadcasterGroup(BroadcasterGroup.Hittable);
			Categories.Platforming.Add(new PreloadObject("Large Bell", "bell_l", ("Bone_01c", "bell_bench/frame/Bell Main Parent"), null, delegate(GameObject o)
			{
				PlayMakerFSM val3 = FSMUtility.LocateMyFSM(((Component)o.transform.GetChild(2)).gameObject, "interactive_bell");
				val3.fsmTemplate = null;
				val3.GetState("Apply Force").AddAction(delegate
				{
					o.BroadcastEvent("OnHit");
				}, 0, everyFrame: false);
			}, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, -0.004f);
				((Component)o.transform.GetChild(2)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
				((Renderer)((Component)o.transform.GetChild(2).GetChild(1)).GetComponent<SpriteRenderer>()).enabled = false;
				((Component)o.transform.GetChild(2).GetChild(3)).gameObject.SetActive(false);
				SpriteRenderer[] componentsInChildren = o.GetComponentsInChildren<SpriteRenderer>();
				foreach (SpriteRenderer val2 in componentsInChildren)
				{
					val2.maskInteraction = (SpriteMaskInteraction)0;
				}
			})).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations).WithBroadcasterGroup(BroadcasterGroup.Hittable);
			Categories.Misc.Add(new PreloadObject("Hornet Cocoon", "hornet_cocoon", ("herodynamic_assets_all", "Assets/Prefabs/Heroes/Hornet Cocoon Corpse.prefab"), null, delegate(GameObject o)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Expected O, but got Unknown
				o.GetComponent<HitResponse>().OnHit.AddListener((UnityAction)delegate
				{
					o.BroadcastEvent("OnHit");
				});
				o.GetComponent<PlayMakerFSM>().GetState("Break").AddAction(delegate
				{
					o.BroadcastEvent("OnHit");
				}, -1, everyFrame: false);
			}, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(1).GetChild(0)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}, preview: false, notSceneBundle: true).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Cocoon).WithBroadcasterGroup(BroadcasterGroup.Hittable));
			Categories.Misc.Add(new PreloadObject("Double Harp Tablet", "weaver_harp_sign_double", ("Mosstown_02", "lore_tablet"), "Use <br> for a new line, <page> for a new page,\nand <hpage> for one where Hornet speaks.\n\nUse <color>, <b>, <i>, <s> and <u> to format text.\nFor example: '<b><color=#FF0000>YOU</color></b>'", null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(1).GetChild(1)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.DoubleLoreTablet));
			Categories.Misc.Add(new PreloadObject("Harp Tablet", "weaver_harp_sign", ("Shellwood_10", "weaver_harp_sign"), "Use <br> for a new line, <page> for a new page,\nand <hpage> for one where Hornet speaks.\n\nUse <color>, <b>, <i>, <s> and <u> to format text.\nFor example: '<b><color=#FF0000>YOU</color></b>'", null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(1)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LoreTablets));
			Categories.Misc.Add(new PreloadObject("Coral Tablet", "coral_tablet", ("Coral_Tower_01", "Coral Crust Lore Tablet"), null, preloadAction: InteractableFixers.FixCoralNut, postSpawnAction: InteractableFixers.FixActivator).WithBroadcasterGroup(BroadcasterGroup.ActiveDeactivatable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LoreTablets));
			Categories.Misc.Add(new PreloadObject("Trobbio Sign", "trobbio_sign", ("Library_13", "Grand Stage Scene/First_Stage/Post_defeat_set/trobbio_signpost"), null, delegate(GameObject o)
			{
				((Behaviour)o.GetComponent<HitResponse>()).enabled = true;
			}, delegate(GameObject o)
			{
				EnemyFixers.RemoveConstrainPosition(o);
				Extensions.SetPositionZ(o.transform, 0f);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LoreTablets));
			Categories.Misc.Add(new PreloadObject("Mushroom Tablet", "mushroom_tablet", ("Aqueduct_05", "Mr_Mush_Tablet_St/Mr Mushroom Tablet"), null, null, MiscFixers.AddComponent<MiscFixers.MushroomTablet>).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Dialogue).WithReceiverGroup(ReceiverGroup.MushTablet).WithBroadcasterGroup(BroadcasterGroup.Finishable));
			Categories.Misc.Add(new PreloadObject("Abyss Tablet", "abyss_tablet", ("Abyss_02b", "Abyss_lore_stone")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LoreTablets));
		}

		private static void AddMemoriumObjects()
		{
			AddSolid("Memorium Platform 1", "memorium_plat_2", ("Arborium_03", "hanging_gardens_plat_float_metal_small (3)"));
			AddSolid("Memorium Platform 2", "memorium_plat_1", ("Arborium_03", "Arborium Plat Mid"));
			AddEnemy("Memoria", "memoria", ("Arborium_03", "Arborium Keeper"), null, notSceneBundle: false, EnemyFixers.FixFlyin);
			AddEnemy("Huge Flea", "huge_flea", ("Arborium_08", "Giant Flea Scene/Giant Flea"), null, notSceneBundle: false, null, EnemyFixers.FixGiantFlea).WithBroadcasterGroup(BroadcasterGroup.Bosses).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.HugeFlea);
		}

		private static void AddCogworksObjects()
		{
			Categories.Hazards.Add(new PreloadObject("Fan", "fan_hazard", ("Under_03", "fan_hazard"), null, null, HazardFixers.FixFan).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards));
			Categories.Hazards.Add(new PreloadObject("Small Cog", "spike_cog_1", ("Cog_04", "cog_rail_hazard (9)/cog"), null, null, HazardFixers.FixCog).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Cogs));
			Categories.Hazards.Add(new PreloadObject("Large Grey Cog", "spike_cog_2", ("Cog_04", "Spike_cog_set_core (5)/Spike Cog 2"), null, preloadAction: HazardFixers.FixLargeCog, postSpawnAction: HazardFixers.FixLargeCogAfterSpawn).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Cogs));
			Categories.Hazards.Add(new PreloadObject("Large Gold Cog", "spike_cog_3", ("Cog_04", "Spike_cog_set_core (5)/Spike Cog 3 (1)"), null, preloadAction: HazardFixers.FixLargeCog, postSpawnAction: HazardFixers.FixLargeCogAfterSpawn).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Cogs));
			Categories.Interactable.Add(new PreloadObject("Cog Lever", "harpoon_ring_citadel", ("Cog_04", "cog_lever"), null, preloadAction: InteractableFixers.FixCogLeverPreload, postSpawnAction: InteractableFixers.FixCogLever).WithBroadcasterGroup(BroadcasterGroup.Levers).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Levers));
			Categories.Interactable.Add(new PreloadObject("Reusable Cog Lever", "reusable_cog_lever", ("Cog_09", "puzzle cylinders/Cog_Choir_Cylinder/Anim Offset/Cog 1/puzzle cog lever"), null, InteractableFixers.FixReusableCogLever, delegate(GameObject o)
			{
				o.transform.GetChild(3).SetAsFirstSibling();
				Extensions.SetPositionZ(o.transform, -0.46f);
			}).WithBroadcasterGroup(BroadcasterGroup.Activatable));
			AddEnemy("Cogwork Choirbug", "song_auto_1", ("Cog_04", "Black Thread States Thread Only Variant/Normal World/Song Automaton 01")).DoFlipX();
			AddEnemy("Cogwork Defender", "cogwork_defender", ("Cog_06", "Song Automaton Shield"), null, notSceneBundle: false, null, delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").GetState("Init").DisableAction(1);
			}).DoFlipX();
			AddEnemy("Cogwork Spine", "cogwork_spine", ("Cog_05", "Battle Scene/Wave 2/Song Automaton Fly Spike"), null, notSceneBundle: false, EnemyFixers.FixCogworkSpine).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Patroller);
			AddEnemy("Cogwork Cleanser", "song_auto_2", ("Cog_04", "Black Thread States Thread Only Variant/Black Thread World/Group (1)/Song Automaton 02"));
			AddEnemy("Cogwork Crawler", "song_auto_crawl", ("Cog_04", "Song Automaton Goomba"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition).WithRotateAction(delegate(GameObject obj, float rot)
			{
				if (Mathf.RoundToInt(rot / 180f) == 1)
				{
					Extensions.SetScaleY(obj.transform, 0f - Extensions.GetScaleY(obj.transform));
					Extensions.SetRotation2D(obj.transform, Extensions.GetRotation2D(obj.transform) + rot - 180f);
				}
			}).WithRotationGroup(RotationGroup.Vertical);
			AddEnemy("Cogworker", "cogworker", ("Cog_07", "Black Thread States/Normal World/Song Automaton Fly (3)"), null, notSceneBundle: false, delegate(GameObject o)
			{
				tk2dSpriteAnimator component = o.GetComponent<tk2dSpriteAnimator>();
				component.defaultClipId = component.GetClipIdByName("Battler");
			}, EnemyFixers.FixCogworker);
			AddEnemy("Cogwork Clapper", "cog_clapper", ("Cog_07", "Black Thread States/Normal World/Repairable Scene/Song Automaton Ball (1)"), null, notSceneBundle: false, EnemyFixers.FixCogworkClapperAnim, EnemyFixers.FixCogworkClapper);
			AddSolid("Cogworks Platform 1", "cog_plat_1", ("Cog_04", "cog_plat_float_tiny (1)"), MiscFixers.FocusFirstChild);
			AddSolid("Cogworks Platform 2", "cog_plat_2", ("Cog_04", "cog_plat_float (2)"), MiscFixers.FocusFirstChild);
			Categories.Interactable.Add(new PreloadObject("Bell Lock", "bell_lock", ("Arborium_10", "Music Box Sequence - EDITED/bells/music_box_support"), null, delegate(GameObject o)
			{
				BouncePod componentInChildren = o.GetComponentInChildren<BouncePod>();
				componentInChildren.InertHit += delegate
				{
					o.BroadcastEvent("OnHit");
				};
				componentInChildren.BounceHit += delegate
				{
					o.BroadcastEvent("OnHit");
				};
			}, delegate(GameObject o)
			{
				o.GetComponentInChildren<Rigidbody2D>(true).constraints = (RigidbodyConstraints2D)7;
				Extensions.SetPositionZ(o.transform, 0.1237f);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BellPod).WithReceiverGroup(ReceiverGroup.BellPod).WithBroadcasterGroup(BroadcasterGroup.Hittable));
		}

		private static void AddBellObjects()
		{
			AddEnemy("Furm", "furm", ("Belltown_basement_03", "Bell Goomba"), null, notSceneBundle: false, null, EnemyFixers.FixFurm).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Furm).WithRotationGroup(RotationGroup.Four).DoFlipX();
			AddEnemy("Winged Furm", "winged_furm", ("Belltown_basement_03", "Bell Fly"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition, EnemyFixers.FixWingedFurm).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.WingedFurm);
			Categories.Hazards.Add(new PreloadObject("Falling Bell", "falling_bell", ("Belltown_04", "Drop Bell (1)")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FallingBell).WithReceiverGroup(ReceiverGroup.Dropper));
			AddSolid("Bell Platform 1", "bell_plat_1", ("Belltown", "hanging_bell_house 2/plat_float_07"), delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, -0.1174f);
			});
			AddSolid("Bell Platform 2", "bell_plat_2", ("Belltown", "Hornet House States/Full/plat_float_07 (1)"), delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, -0.1174f);
				Extensions.SetLocalPositionZ(o.transform.GetChild(0), 0.001f);
			});
			AddSolid("Bell Platform 3", "bell_plat_3", ("Belltown", "Black Thread States Thread Only Variant/Normal World/shop_sign"), delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, -0.1174f);
				Extensions.SetRotation2D(o.transform, 0f);
				for (int i = 2; i <= 5; i++)
				{
					((Component)o.transform.GetChild(i)).gameObject.SetActive(false);
				}
				((Component)o.transform.GetChild(1).GetChild(3)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BellPlat3);
			Categories.Attacks.Add(new PreloadObject("Throwing Bell", "throwing_bell", ("localpoolprefabs_assets_areasong", "Assets/Prefabs/Enemies/Fungus 1 + 2/Throwing Bell.prefab"), null, null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Npcs.Add(new PreloadObject("Pin Pilgrim NPC", "pin_pilgrim_npc", ("Belltown", "Pin Pilgrim"), null, null, MiscFixers.FixPinPilgrim).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Npcs.Add(new PreloadObject("Pavo NPC", "pavo_normal", ("Belltown", "Town States/Spinner Defeated/Bagpipers Not Here/Belltown Greeter NPC"), null, MiscFixers.FixPavo).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Pavo).WithBroadcasterGroup(BroadcasterGroup.Npcs).DoFlipX());
			Categories.Npcs.Add(new PreloadObject("Sad Pavo NPC", "pavo_sad", ("Belltown", "Town States/Spinner Defeated/Bagpipers Not Here/Belltown Greeter Act3"), null, MiscFixers.FixSadPavo).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Attacks.Add(new PreloadObject("Bell Eater Bullet", "bell_bullet", ("localpoolprefabs_assets_areabellway", "Assets/Prefabs/Enemies/Projectiles/Shot Giant Centipede.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Attacks.Add(new PreloadObject("Bell Eater Bomb", "bell_bomb", ("localpoolprefabs_assets_areabellway", "Assets/Prefabs/Hornet Bosses/Giant Centipede Bomb.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
		}

		private static void AddWispObjects()
		{
			Categories.Platforming.Add(new PreloadObject("Sprintmaster Bounce Pod", "sprintmaster_pod", ("Sprintmaster_Cave", "Race Group/Tracks/Track 2/Sprintmaster Bounce Pod (4)")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bell));
			Categories.Platforming.Add(new PreloadObject("Wisp Bounce Pod", "wisp_bounce_pod", ("Wisp_02", "Wisp Bounce Pod")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bell));
			Categories.Hazards.Add(new PreloadObject("Wispfire Lantern", "wisp_flame_lantern", ("Wisp_02", "Wisp Farmers/Wisp Flame Lantern"), null, preloadAction: HazardFixers.FixWispLantern, postSpawnAction: MiscFixers.FixBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.WispLanterns).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Attacks.Add(new PreloadObject("Wisp", "wisp", ("localpoolprefabs_assets_areawisp.bundle", "Assets/Prefabs/Hornet Enemies/Wisp Fireball.prefab"), null, HazardFixers.FixWisp, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wisp).WithReceiverGroup(ReceiverGroup.Wisp));
			AddEnemy("Burning Bug", "farmer_wisp", ("Wisp_02", "Wisp Farmers/Farmer Wisp"), null, notSceneBundle: false, delegate(GameObject o)
			{
				EnemyFixers.KeepActive(o);
				tk2dSpriteAnimator component = o.GetComponent<tk2dSpriteAnimator>();
				component.defaultClipId = component.GetClipIdByName("Idle");
				FsmState state = FSMUtility.LocateMyFSM(o, "Control").GetState("Choice");
				state.transitions = state.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BurningBug).DoFlipX();
		}

		private static void AddShellwoodObjects()
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Expected O, but got Unknown
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			Categories.Hazards.Add(MiscObjects.CreateCustomHazard("Shellwood Thorns", "shellwood_thorns", (Vector2[])(object)new Vector2[9]
			{
				new Vector2(-3.272f, -1.265f),
				new Vector2(-3.011f, 0.066f),
				new Vector2(-1.269f, 0.777f),
				new Vector2(0.474f, 1.182f),
				new Vector2(2.553f, 1.113f),
				new Vector2(3.554f, -0.694f),
				new Vector2(0.474f, -1.382f),
				new Vector2(-1.399f, -0.882f),
				new Vector2(-3.272f, -1.265f)
			}));
			AddSolid("Shellwood Platform 1", "wood_plat_1", ("Shellwood_01", "shellwood_plat_float_thin"));
			AddSolid("Shellwood Platform 2", "wood_plat_2", ("Shellwood_01", "shellwood_plat_float_wide"));
			Categories.Platforming.Add(new PreloadObject("Bouncebloom", "bounce_bloom", ("Arborium_05", "Shellwood Bounce Bloom")));
			AddEnemy("Pond Skipper", "pond_skater", ("Arborium_05", "Pond Skater"), null, notSceneBundle: false, null, delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Control").GetState("Init").DisableAction(0);
			});
			AddEnemy("Pondcatcher", "pilgrim_fisher", ("Shellwood_01", "Black Thread States/Normal World/Pilgrim Fisher Enemy (1)"));
			AddEnemy("Gahlia", "bloom_puncher", ("Arborium_05", "Bloom Puncher"), null, notSceneBundle: false, EnemyFixers.RotateCorpse).WithRotationGroup(RotationGroup.Four);
			AddEnemy("Phacia", "flower_drifter", ("Shellwood_10", "Flower Drifter"));
			AddEnemy("Disguised Phacia", "flower_drifter_hidden", ("Arborium_03", "Flower Drifter (3)"));
			GameObject sphere = new GameObject("Pollen Flare");
			sphere.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)sphere);
			PreloadManager.RegisterPreload(new BasicPreload("Arborium_03", "Flower Drifter (4)/pollen_flare_attack", delegate(GameObject o)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				Object.Instantiate<GameObject>(o, sphere.transform).transform.localPosition = Vector3.zero;
			}));
			Categories.Attacks.Add(new CustomObject("Pollen Flare", "pollen_flare", sphere, null, null, preview: false, ResourceUtils.LoadSpriteResource("pollen_ring", (FilterMode)1, default(Vector4), 24f)).WithReceiverGroup(ReceiverGroup.Burst));
			AddEnemy("Pollenica", "bloom_shooter", ("Arborium_03", "Bloom Shooter"), null, notSceneBundle: false, EnemyFixers.RotateCorpse).WithRotationGroup(RotationGroup.Eight);
			AddEnemy("Wood Wasp", "wood_wasp", ("Shellwood_02", "Shellwood Wasp"));
			AddEnemy("Splinter", "splinter", ("Shellwood_02", "Stick Insect"), null, notSceneBundle: false, EnemyFixers.FixSplinter, EnemyFixers.FinishSplinterFix);
			AddEnemy("Splinterhorn", "splinterhorn", ("Shellwood_02", "Stick Insect Charger"), null, notSceneBundle: false, EnemyFixers.FixSplinter, EnemyFixers.FinishSplinterFix);
			AddEnemy("Splinterbark", "splinterbark", ("Shellwood_26", "Black Thread States/Normal World/Stick Insect Flyer (1)"));
			AddEnemy("Crawling Shellwood Gnat", "shellwood_gnat", ("Shellwood_01", "Shellwood Goomba")).DoFlipX();
			AddEnemy("Flying Shellwood Gnat", "shellwood_gnat_fly", ("Shellwood_01", "Shellwood Goomba Flyer (1)"));
			AddEnemy("Shellwood Gnat Core", "shellwood_gnat_core", ("localpoolprefabs_assets_areashellwood.bundle", "Assets/Prefabs/Hornet Enemies/Shellwood Gnat.prefab"), null, notSceneBundle: true);
			Categories.Effects.Add(new PreloadObject("Pollen Effect", "pollen_effect", ("Shellwood_10", "pollen_particles (1)"), "Affects the whole room.", null, MiscFixers.FixDecoration, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("pollen", (FilterMode)1, default(Vector4), 377.5f))).WithScaleAction(delegate(GameObject o, float f)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, new Vector2(f, f));
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Decorations);
			Categories.Misc.Add(new PreloadObject("Pond Skipper Body", "pond_skipper_body", ("Belltown_Room_shellwood", "shell_hang_rope"), null, null, MiscFixers.FixDisabledBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bell).WithBroadcasterGroup(BroadcasterGroup.Breakable));
		}

		private static void AddMarchObjects()
		{
			AddEnemy("Skarrlid", "bone_hunter_tiny", ("Ant_04", "Black Thread States Thread Only Variant/Normal World/Bone Hunter Tiny"), null, notSceneBundle: false, MiscFixers.FixRotation);
			AddEnemy("Skarrwing", "bone_hunter_buzzer", ("Ant_04", "Black Thread States Thread Only Variant/Normal World/Bone Hunter Buzzer"), null, notSceneBundle: false, MiscFixers.FixRotation).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Skarrwing);
			AddEnemy("Skarr Scout", "bone_hunter_child", ("Ant_04", "Black Thread States Thread Only Variant/Normal World/Bone Hunter Child"), null, notSceneBundle: false, EnemyFixers.FixSkarr);
			AddEnemy("Skarr Stalker", "bone_hunter", ("Ant_04", "Black Thread States Thread Only Variant/Normal World/Bone Hunter"), null, notSceneBundle: false, EnemyFixers.FixSkarr, delegate(GameObject o)
			{
				FSMUtility.LocateMyFSM(o, "Detect Offscreen").GetState("Idle").transitions = Array.Empty<FsmTransition>();
			});
			AddEnemy("Spear Skarr", "bone_hunter_fly", ("Ant_21", "Enemy Control/Ant Merchant Killed/Big Guard Dead/Bone Hunter Fly"), null, notSceneBundle: false, MiscFixers.AddComponent<EnemyFixers.SpearSkarr>).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SpearSkarr).WithReceiverGroup(ReceiverGroup.Wakeable);
			AddEnemy("Skarrgard", "bone_hunter_throw", ("Ant_21", "Enemy Control/Normal/Bone Hunter Throw"), null, notSceneBundle: false, EnemyFixers.KeepActiveRemoveConstrainPos);
			Categories.Misc.Add(new PreloadObject("Skarr String Shard", "ant_string_shard", ("Ant_04", "Black Thread States Thread Only Variant/Normal World/ant_shell_shard_string (2)"), null, null, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.01f);
				MiscFixers.FixRotation(o);
			}).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			Categories.Misc.Add(new PreloadObject("Skarr String S", "ros_str_s", ("Ant_21", "ant_rosary_string"), null, null, MiscFixers.FixRotation).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			Categories.Misc.Add(new PreloadObject("Skarr String M", "ros_str_m", ("Ant_21", "ant_rosary_string_medium (1)"), null, null, MiscFixers.FixRotation).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			Categories.Misc.Add(new PreloadObject("Skarr String L", "ros_str_l", ("Ant_21", "ant_rosary_string_large"), null, null, MiscFixers.FixRotation).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			AddEnemy("Last Claw", "last_claw", ("Memory_Ant_Queen", "Boss Scene/Battle Scene/Wave 4/Bone Hunter Fly Chief"), null, notSceneBundle: false, EnemyFixers.FixLastClawPreload, EnemyFixers.FixLastClaw).WithScaleAction(EnemyFixers.ScaleLastClaw).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LastClaw);
			AddEnemy("Skarrsinger Karmelita", "karmelita", ("Memory_Ant_Queen", "Boss Scene/Hunter Queen Boss"), null, notSceneBundle: false, EnemyFixers.FixKarmelitaPreload, EnemyFixers.FixKarmelita).WithBroadcasterGroup(BroadcasterGroup.Karmelita).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses);
			Categories.Platforming.Add(new PreloadObject("Hunterfruit", "march_pogo", ("Ant_04", "White Palace Fly")));
			Categories.Platforming.Add(new PreloadObject("Bending Pole Ring", "march_ring", ("Ant_09", "Fields Harpoon Ring Pole"), null, null, MiscFixers.FixPoleRing).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PoleRing));
			Categories.Hazards.Add(new PreloadObject("Sickle Trap", "hunter_sickle_trap", ("Ant_04", "Hunter Sickle Trap")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards).WithReceiverGroup(ReceiverGroup.Trap)).DoFlipX();
			Categories.Hazards.Add(new PreloadObject("Gurr Trap", "hunter_landmine", ("Bone_East_24", "Ant Trapper Quest Scene (3)/Tracking Scene/Trapper Barb Trap Landmine")).WithReceiverGroup(ReceiverGroup.Trap).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards).WithRotationGroup(RotationGroup.All));
			Categories.Interactable.Add(new PreloadObject("Skarr Pressure Plate", "hunter_trap_plate", ("Ant_04", "Hunter Trap Plate"), null, InteractableFixers.FixMarchPlate).WithBroadcasterGroup(BroadcasterGroup.Activatable)).DoFlipX();
			Categories.Interactable.Add(new PreloadObject("Skarr Cage", "ant_trap_cage", ("Ant_04", "Hunter Trap Cage (1)")).WithReceiverGroup(ReceiverGroup.Trap).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			Categories.Attacks.Add(new PreloadObject("Skarr Sickle", "sickle_attack_s", ("localpoolprefabs_assets_areaant", "Assets/Prefabs/Hornet Enemies/Hunter Child Sickle.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.VelocityDamager).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Attacks.Add(new PreloadObject("Skarr Javelin", "javelin_attack", ("localpoolprefabs_assets_areaant", "Assets/Prefabs/Hornet Enemies/Bone Hunter Javelin.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Attacks.Add(new PreloadObject("Large Skarr Javelin", "sickle_attack_l", ("localpoolprefabs_assets_areaantareamemory", "Assets/Prefabs/Hornet Enemies/Bone Hunter Chief Javelin.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
		}

		private static void AddMarrowObjects()
		{
			AddEnemy("Skull Scuttler", "bone_goomba", ("Bone_East_03", "Black Thread States Thread Only Variant/Normal World/Bone Goomba"), null, notSceneBundle: false, MiscFixers.FixRotation);
			AddEnemy("Skullwing", "bone_goomba_bounce_fly", ("Weave_05b", "Bone Goomba Bounce Fly (11)"), null, notSceneBundle: false, MiscFixers.FixRotation);
			AddEnemy("Skull Brute", "bone_goomba_l", ("Bone_East_03", "Black Thread States Thread Only Variant/Normal World/Bone Goomba Large"), null, notSceneBundle: false, MiscFixers.FixRotation);
			AddEnemy("Skull Tyrant", "skull_tyrant", ("Bonetown_boss", "Boss Scene/Skull King"), null, notSceneBundle: false, null, EnemyFixers.FixSkullTyrant).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.SkullTyrant);
			Categories.Misc.Add(new PreloadObject("Skull", "bone_goomba_skull", ("Bone_East_03", "bone_goomba_skull_break"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Large Skull", "bone_goomba_skull_large", ("Bone_East_03", "bone_goomba_skull_break_large)"), null, MiscFixers.FixBreakable).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Pilgrim Dummy 1", "pilgrim_dummy_1", ("Bone_12", "Black Thread States/Normal World/Pin Gallery States/Not Here/Hanging Dummy 01")));
			Categories.Misc.Add(new PreloadObject("Pilgrim Dummy 2", "pilgrim_dummy_2", ("Bone_12", "Black Thread States/Normal World/Pin Gallery States/Not Here/Hanging Dummy 02")));
			Categories.Misc.Add(new PreloadObject("Pilgrim Dummy 3", "pilgrim_dummy_3", ("Bone_12", "Black Thread States/Normal World/Pin Gallery States/Not Here/Hanging Dummy 03")));
			Categories.Interactable.Add(new PreloadObject("Silk Vines", "silk_vines", ("Mosstown_02", "Black Thread States Thread Only Variant/Normal World/Thick Silk Vines"), null, preloadAction: InteractableFixers.FixSilkVinesPreload, postSpawnAction: InteractableFixers.FixSilkVines).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable).WithBroadcasterGroup(BroadcasterGroup.SilkVines));
			Categories.Interactable.Add(new PreloadObject("Collapsing Bone Platform", "collapser_rock", ("Bone_01", "Battle Scene/Collapser Small (1)"), null, null, delegate(GameObject o)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				foreach (Transform item in o.transform.GetChild(0))
				{
					Transform val = item;
					((Component)val).gameObject.SetActive(false);
				}
				Extensions.SetLocalPositionZ(o.transform, 0.006f);
				Extensions.SetLocalPositionX(o.transform.GetChild(0), 2.8f);
				((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			Categories.Interactable.Add(new PreloadObject("Collapsing Underworks Platform", "collapser_under", ("Under_05", "Collapser Small Understore Grate"), null, null, delegate(GameObject o)
			{
				Extensions.SetLocalPositionX(o.transform.GetChild(6).GetChild(0), 3.1f);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PersistentBreakable));
			AddEnemy("Caranid", "bone_circler", ("Bone_East_03", "Black Thread States Thread Only Variant/Normal World/Hunting PreScene/Bone Circler"));
			AddEnemy("Vicious Caranid", "bone_circler_v", ("Bone_East_03", "Black Thread States Thread Only Variant/Black Thread World/Bone Circler Vicious (1)"), null, notSceneBundle: false, MiscFixers.FixRotation).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.HideBody);
			AddEnemy("Kilik", "bone_crawler", ("Ant_19", "Bone Crawler (2)"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition).WithRotationGroup(RotationGroup.Four);
			AddEnemy("Beastfly", "beastfly", ("Ant_19", "Enemy Break Cage (9)/Enemy/Bone Flyer"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition).DoFlipX();
			AddEnemy("Savage Beastfly", "savage_beastfly", ("Ant_19", "Boss Control/Boss Scene/Bone Flyer Giant"), null, notSceneBundle: false, EnemyFixers.RemoveConstrainPosition, EnemyFixers.FixSavageBeastfly).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.SavageBeastfly).WithBroadcasterGroup(BroadcasterGroup.SavageBeastfly).DoFlipX();
			AddEnemy("Mawling", "bone_roller", ("Arborium_03", "Bone Roller"));
			AddEnemy("Marrowmaw", "bone_thumper", ("Arborium_04", "Enemy Respawner/Source Folder/Bone Thumper"), null, notSceneBundle: false, EnemyFixers.ApplyGravity);
			AddEnemy("Tarmite", "tarmite", ("Bone_East_LavaChallenge", "Bone Spitter"), null, notSceneBundle: false, EnemyFixers.KeepActive);
			AddEnemy("Flintbeetle", "flintbeetle", ("Bone_06", "Rock Roller Scene/Rock Roller"), null, notSceneBundle: false, EnemyFixers.FixFlintbeetlePreload, EnemyFixers.FixFlintbeetle).WithRotationGroup(RotationGroup.Four).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wakeable).WithReceiverGroup(ReceiverGroup.Wakeable);
			Categories.Attacks.Add(new PreloadObject("Flintrock", "flint_bomb", ("localpoolprefabs_assets_areabone.bundle", "Assets/Prefabs/Enemies/Projectiles/Rock Roller Bomb.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Shardillard", "shardillard", ("Bone_06", "Shell Fossil Mimic AppearVariant"), null, notSceneBundle: false, MiscFixers.FixRotation, EnemyFixers.FixShardillard).WithReceiverGroup(ReceiverGroup.Wakeable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wakeable).WithBroadcasterGroup(BroadcasterGroup.Shardillard)
				.DoFlipX();
			Categories.Platforming.Add(new PreloadObject("Magnetite Platform 1", "bone_plat_crumble_1", ("Bone_East_LavaChallenge", "bone_plat_01_crumble_small (2)")));
			Categories.Platforming.Add(new PreloadObject("Magnetite Platform 2", "bone_plat_crumble_2", ("Bone_East_LavaChallenge", "bone_plat_01_crumble (2)")));
			Categories.Platforming.Add(new PreloadObject("Magnetite Platform 3", "bone_plat_crumble_3", ("Bone_East_LavaChallenge", "bone_plat_02_crumble (1)")));
			Categories.Platforming.Add(new PreloadObject("Magnetite Platform 4", "bone_plat_crumble_4", ("Bone_East_LavaChallenge", "bone_plat_crumble_tall (4)")));
			Categories.Hazards.Add(new PreloadObject("Bone Boulder", "bone_boulder", ("Bone_East_03", "Black Thread States Thread Only Variant/Normal World/Bone_Boulder"), null, delegate(GameObject o)
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(o, "Control");
				fsm.GetState("Break").AddAction(delegate
				{
					o.BroadcastEvent("OnBreak");
				}, 0, everyFrame: false);
				fsm.GetState("Deactivate").AddAction(delegate
				{
					o.BroadcastEvent("OnBreak");
				}, 0, everyFrame: false);
			}, MiscFixers.FixRotation).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards).WithReceiverGroup(ReceiverGroup.Dropper).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Interactable.Add(new PreloadObject("Bone Lever", "bone_lever", ("Mosstown_01", "Bone Lever"), null, InteractableFixers.FixLever).WithBroadcasterGroup(BroadcasterGroup.Levers).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Levers).WithRotationGroup(RotationGroup.Eight));
			Categories.Interactable.Add(new PreloadObject("Bone Gate", "bone_gate", ("Chapel_Wanderer", "Battle Scene/Gates/Battle Gate Bone"), null, null, delegate(GameObject o)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				BoxCollider2D component = o.GetComponent<BoxCollider2D>();
				((Collider2D)component).offset = Vector2.zero;
				component.size = new Vector2(1.5f, 6f);
				Object.Destroy((Object)(object)((Component)o.transform.Find("Wall Collider")).gameObject);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CloseableGates).WithReceiverGroup(ReceiverGroup.BattleGate).WithRotationGroup(RotationGroup.Four));
			AddSolid("Bone Platform 1", "marrow_plat_01", ("Bone_East_03", "bone_plat_02 (2)"));
			AddSolid("Bone Platform 2", "bone_plat_03", ("Bone_East_03", "bone_plat_03 (2)"));
			AddSolid("Bone Platform 3", "marrow_plat_02", ("Bone_East_03", "bone_plat_03 (6)"));
			Categories.Misc.Add(new PreloadObject("Beastling", "bellbeast_child", ("localpoolprefabs_assets_shared", "Assets/Prefabs/Hornet NPCs/Bellbeast Child.prefab"), null, MiscFixers.FixBellBaby, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.TriggerActivator).WithBroadcasterGroup(BroadcasterGroup.Hittable));
		}

		private static void AddDocksObjects()
		{
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Smelt Shoveller", "dock_worker", ("Bone_East_03", "Dock Worker"));
			AddEnemy("Flintstone Flyer", "dock_flyer", ("Bone_East_01", "Black Thread States Thread Only Variant/Normal World/Dock Flyer"), null, notSceneBundle: false, null, EnemyFixers.FixFlintFlyer);
			AddEnemy("Lavalug", "tar_slug", ("Dock_02", "Tar Slug")).WithRotationGroup(RotationGroup.Four).DoFlipX();
			AddEnemy("Lavalarga", "tar_slug_huge", ("Dock_11", "Tar Slug Huge (1)")).WithRotationGroup(RotationGroup.Four);
			AddEnemy("Flintflame Flyer", "dock_bomber", ("Dock_02", "Dock Bomber"), null, notSceneBundle: false, null, EnemyFixers.FixFlintFlyer);
			Categories.Effects.Add(new PreloadObject("Heat Effect", "heat_plane", ("Dock_02", "HeatPlane"), Settings.PrideMode ? "From Fire" : null, null, delegate(GameObject o)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				o.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("heat", (FilterMode)1, default(Vector4), 20f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.HeatPlane));
			Categories.Attacks.Add(new PreloadObject("Flintbomb", "flintflame_bomb", ("localpoolprefabs_assets_areadocks", "Assets/Prefabs/Enemies/Projectiles/DF Bomb Rock.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", HazardFixers.FixFlintbomb, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithBroadcasterGroup(BroadcasterGroup.Exploding)
				.WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Smokerock Sifter", "shield_dockworker", ("Dock_02", "Shield Dockworker Spawn/Shield Dockworker (2)"));
			AddEnemy("Deep Diver", "dock_charger", ("Dock_02b", "Dock Charger")).DoFlipX();
			Categories.Interactable.Add(new PreloadObject("Deep Docks Gate", "song_gate_small", ("Bone_East_15", "Song_Gate_small (3)"), null, null, delegate(GameObject o)
			{
				o.RemoveComponent<PersistentBoolItem>();
			}).WithReceiverGroup(ReceiverGroup.Gates).WithRotationGroup(RotationGroup.Eight));
			Categories.Interactable.Add(new PreloadObject("Deep Docks Lever", "song_lever_side", ("Bone_East_15", "Song_lever_side"), null, InteractableFixers.FixLever).WithBroadcasterGroup(BroadcasterGroup.Levers).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Levers).WithRotationGroup(RotationGroup.Eight)
				.DoFlipX());
			AddSolid("Docks Platform 1", "dock_plat_01", ("Bone_East_01", "dock_plat_float_01 (1)"));
			AddSolid("Docks Platform 2", "dock_plat_02", ("Bone_East_01", "dock_plat_float_01 (9)"));
			Categories.Platforming.Add(new PreloadObject("Crumbling Rocks 1", "lava_crumble_plat", ("Dock_02b", "lava_crumble_plat (5)")).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CrumblePlat));
			Categories.Hazards.Add(new PreloadObject("Hot Coals", "hot_coal", ("Bone_East_03", "lava_rocks_top_glower"), null, HazardFixers.FixCoal, delegate(GameObject o)
			{
				o.transform.GetChild(0).Translate(-6.6806f, -0.9279f, 0f);
				o.transform.GetChild(1).Translate(-6.6806f, -0.9279f, 0f);
			}));
			Categories.Hazards.Add(new PreloadObject("Lava", "lava_area", ("Bone_East_09", "lava_set/LavaBase (1)"), null, HazardFixers.FixLava, delegate(GameObject o)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				o.transform.localScale = new Vector3(20f, 5f, 0f);
				Extensions.SetPositionZ(o.transform, -0.002f);
			}, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("lava", (FilterMode)0, default(Vector4), 128f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.StretchableHazards));
			PlaceableObject placeableObject = Categories.Hazards.Add(new PreloadObject("Falling Lava", "falling_lava", ("Under_19", "Lava_Waterfall Set (4)"), null, null, delegate(GameObject o)
			{
				((Component)o.transform.GetChild(0).GetChild(0).GetChild(0)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards));
			placeableObject.Offset -= new Vector3(0f, 8f, 0f);
			AddEnemy("Forebrother Signis", "forebrother_signis", ("Dock_09", "Boss Scene/Dock Guard Slasher"), null, notSceneBundle: false, null, EnemyFixers.FixSignis).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.SummonerBosses);
			AddEnemy("Forebrother Gron", "forebrother_gron", ("Dock_09", "Boss Scene/Dock Guard Thrower"), null, notSceneBundle: false, null, EnemyFixers.FixGron).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses).WithBroadcasterGroup(BroadcasterGroup.Bosses).DoFlipX();
			Categories.Npcs.Add(new PreloadObject("Forge Daughter", "forge_daughter_npc", ("Room_Forge", "_NPCs/Forge Daughter"), null, null, MiscFixers.FixForgeDaughter).WithBroadcasterGroup(BroadcasterGroup.Npcs).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).DoFlipX());
		}

		private static void AddFieldsObjects()
		{
			AddSolid("Far Fields Platform 1", "fung_plat_float_01", ("Bone_East_15", "fung_plat_float_06"));
			AddSolid("Far Fields Platform 2", "fung_plat_float_02", ("Bone_East_14", "bone_plat_03"));
			Categories.Interactable.Add(new PreloadObject("Falling Exploding Rock", "boom_rock_fall", ("Bone_East_14", "Explode Floor Scene/DropBomb Rock (2)"), null, InteractableFixers.FixFallingRock, delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0f);
			}).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable).WithReceiverGroup(ReceiverGroup.FallingRock));
			AddEnemy("Brushflit", "brushflit", ("Bone_East_15", "Fields Flock Flyer"), null, notSceneBundle: false, EnemyFixers.FixBrushflit).WithScaleAction(EnemyFixers.ScaleBrushflit);
			AddEnemy("Fertid", "fertid", ("Bone_East_15", "Fields Goomba")).DoFlipX();
			AddEnemy("Flapping Fertid", "flapping_fertid", ("Bone_East_15", "Fields Flyer"), null, notSceneBundle: false, EnemyFixers.FixPatroller).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Patroller).DoFlipX();
			AddEnemy("Hardbone Hopper", "hardbone_hopper", ("Bone_East_24", "Bone Hopper Group/Bone Hopper Simple"));
			AddEnemy("Hardbone Elder", "hardbone_elder", ("Bone_East_24", "Bone Hopper Group/Bone Hopper Giant"));
			AddEnemy("Hoker", "spine_floater", ("Bone_East_14", "Spine Floater (9)"), null, notSceneBundle: false, null, MiscFixers.FixHoker).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hoker).DoFlipX();
			Categories.Interactable.Add(new PreloadObject("Exploding Wall", "exploding_wall", ("Bone_East_14", "explode_wall (4)"), null, preloadAction: InteractableFixers.FixExplodingWallPreload, postSpawnAction: InteractableFixers.FixExplodingWall).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ExplodingWall).WithBroadcasterGroup(BroadcasterGroup.PersistentBreakable));
			Categories.Attacks.Add(new PreloadObject("Spine", "hoker_spine", ("localpoolprefabs_assets_areawilds", "Assets/Prefabs/Hornet Enemies/Spine Floater Spine.prefab"), null, null, null, preview: false, notSceneBundle: true).WithRotationGroup(RotationGroup.All).WithReceiverGroup(ReceiverGroup.Spine));
			AddEnemy("Rhinogrund", "rhino", ("Bone_East_10_Church", "Rhino Scene/Rhino"), null, notSceneBundle: false, EnemyFixers.KeepActive);
			Categories.Misc.Add(new PreloadObject("Sleeping Flea", "flea_1", ("Bone_East_10_Church", "Black Thread States Thread Only Variant/Normal World/Flea Rescue Sleeping"), "Fluffy.\nDoes not add to collected fleas.", MiscFixers.FixFlea, MiscFixers.FixRotation).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Fleas).WithBroadcasterGroup(BroadcasterGroup.Fleas));
			AddEnemy("Fourth Chorus", "fourth_chorus", ("Bone_East_08_boss_golem", "Boss Scene"), null, notSceneBundle: false, EnemyFixers.FixFourthChorusPreload, EnemyFixers.FixFourthChorus).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FourthChorus).WithReceiverGroup(ReceiverGroup.FourthChorus).WithBroadcasterGroup(BroadcasterGroup.Bosses)
				.DoFlipX();
			Categories.Platforming.Add(new PreloadObject("Magma Rocks", "magma_rocks", ("Bone_East_08", "Boss Scene/Pre Activation Floor/Song Golem Floor (8)")).WithReceiverGroup(ReceiverGroup.MagmaRocks));
		}

		private static void AddWormwaysObjects()
		{
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Cragglite", "cragglite", ("Crawl_04", "Little Crabs/Crabs/Small Crab")).WithRotationGroup(RotationGroup.Four).DoFlipX();
			AddEnemy("Craggler", "craggler", ("Crawl_04", "Roof Crab"), null, notSceneBundle: false, null, EnemyFixers.FixCraggler).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Slowdown);
			AddEnemy("Gromling", "gromling", ("Crawl_01", "Crypt Worms/GameObject/Crypt Worm (9)"), null, notSceneBundle: false, null, delegate(GameObject o)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				Transform val = o.transform.Find("Ambush Range");
				val.localPosition = Vector3.zero;
				BoxCollider2D component2 = ((Component)val).GetComponent<BoxCollider2D>();
				((Collider2D)component2).offset = Vector2.zero;
				component2.size = new Vector2(8f, 5f);
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(o, "Control");
				fsm.GetState("Wall?").AddAction(delegate
				{
					o.BroadcastEvent("OnAmbush");
				}, 0, everyFrame: false);
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Gromling).WithBroadcasterGroup(BroadcasterGroup.Ambushers);
			AddEnemy("Grom", "grom", ("Crawl_01", "Bone Worm Nests/Worm Pool/Bone Worm (2)"), null, notSceneBundle: false, null, EnemyFixers.FixGrom).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Grom);
			Categories.Attacks.Add(new PreloadObject("Lifeblood Bullet", "lifeblood_shot", ("localpoolprefabs_assets_lifeblood", "Assets/Prefabs/Hornet Enemies/Lifeblood Projectile.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Misc.Add(new PreloadObject("Winged Lifeseed", "winged_lifeseed", ("localpoolprefabs_assets_lifeblood", "Assets/Prefabs/Items/Health Flyer.prefab"), null, null, null, preview: false, notSceneBundle: true).WithBroadcasterGroup(BroadcasterGroup.Killable));
			AddEnemy("Plasmid", "plasmid", ("Crawl_03", "Area_States/Infected/Bone Worm BlueBlood (1)"), Settings.PrideMode ? "Blåhaj" : null, notSceneBundle: false, null, EnemyFixers.FixPlasmified).DoFlipX();
			AddEnemy("Plasmidas", "plasmidas", ("Crawl_03", "Area_States/Infected/Bone Worm BlueTurret"), null, notSceneBundle: false, delegate(GameObject o)
			{
				((Component)o.transform.Find("blueblood_worm_growths")).gameObject.SetActive(false);
			}, EnemyFixers.FixPlasmidas);
			AddEnemy("Plasmified Zango", "zango_boss", ("Crawl_10", "Area_States/Infected/Blue Assistant"), null, notSceneBundle: false, null, EnemyFixers.FixZango).WithBroadcasterGroup(BroadcasterGroup.Bosses).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bosses);
			PlaceableObject placeableObject = Categories.Misc.Add(new PreloadObject("Lifeblood Pustule", "life_pustule", ("Crawl_03", "PUSTULE_States/Active/pustule_set_small (1)/PUSTULE")).WithRotateAction(delegate(GameObject o, float f)
			{
				Extensions.SetLocalRotation2D(o.transform.GetChild(0), f);
			}).WithFlipAction(delegate(GameObject o, bool f)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				if (f)
				{
					Extensions.SetScaleX(o.transform.GetChild(0), 0f - Extensions.GetScaleX(o.transform.GetChild(0)));
					Extensions.SetLocalPositionX(o.transform.GetChild(0), 0f - o.transform.GetChild(0).localPosition.x);
				}
			}).WithScaleAction(delegate(GameObject o, float s)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				Transform child = o.transform.GetChild(0);
				child.localScale *= s;
				Transform child2 = o.transform.GetChild(0);
				child2.localPosition *= s;
				CircleCollider2D component = o.GetComponent<CircleCollider2D>();
				component.radius *= s;
			}));
			placeableObject.Offset += new Vector3(0f, -0.6f);
			Categories.Misc.Add(new PreloadObject("Lifeblood Cocoon", "health_cocoon", ("Crawl_09", "Area_States/Infected/Health Cocoon")).WithRotateAction(MiscFixers.RotateCocoon).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.LifebloodCocoons).WithReceiverGroup(ReceiverGroup.LifebloodCocoons));
			AddSolid("Wormways Platform 1", "worm_plat_1", ("Crawl_03", "bone_plat_02 (4)"));
			AddSolid("Weavenest Platform 1", "weave_plat_1", ("Crawl_05", "Group/bone_plat_01 (3)"), delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0.006f);
			});
			AddSolid("Weavenest Platform 2", "weave_plat_2", ("Crawl_05", "Crest_shrine_corner_plat (2)"), delegate(GameObject o)
			{
				Extensions.SetPositionZ(o.transform, 0f);
			});
		}

		private static void AddFleaObjects()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Categories.Misc.AddStart(new PreloadObject("Score Counter", "flea_counter", ("Aqueduct_05_festival", "Flea Games Counter"), "If the mode is 'Highest', the score changes colour above each milestone.\nIf the mode is 'Lowest', the score changes colour below each milestone.", null, MiscFixers.FixFleaCounter, preview: false, notSceneBundle: false, ResourceUtils.LoadSpriteResource("flea_counter", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FleaCounter).WithReceiverGroup(ReceiverGroup.FleaCounter).WithInputGroup(InputGroup.FleaCounter)
				.WithOutputGroup(OutputGroup.FleaCounter)
				.WithBroadcasterGroup(BroadcasterGroup.FleaCounter));
			Categories.Npcs.Add(new PreloadObject("Fleamaster NPC", "fleamaster_npc", ("Aqueduct_05_festival", "Caravan_States/Flea Festival/Flea Game - Juggling/Flea Games Host NPC"), null, null, MiscFixers.FixFleamaster).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs));
			Categories.Misc.Add(new PreloadObject("Bounce Flea", "bounce_flea", ("Aqueduct_05_festival", "Caravan_States/Flea Festival/Flea Game - Bouncing/Bellfleas/Bellflea Bouncer"), "Only appears when the FlyStraight or FlyWave trigger is run.", MiscFixers.AddComponent<MiscFixers.BounceFlea>).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BounceFlea).WithReceiverGroup(ReceiverGroup.BounceFlea).WithInputGroup(InputGroup.BounceFlea)
				.WithBroadcasterGroup(BroadcasterGroup.Hittable));
			Categories.Misc.Add(new PreloadObject("Dodge Flea", "dodge_flea", ("Aqueduct_05_festival", "Caravan_States/Flea Festival/Flea Game - Dodging/Bellfleas/Bellflea Swooper"), "Only appears when the Fly trigger is run.", MiscFixers.AddComponent<MiscFixers.DodgeFlea>).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.DodgeFlea).WithReceiverGroup(ReceiverGroup.DodgeFlea).WithInputGroup(InputGroup.DodgeFlea)
				.WithBroadcasterGroup(BroadcasterGroup.Hittable));
		}

		private static void AddMossObjects()
		{
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			AddEnemy("Mossgrub", "mossbone_crawler", ("Arborium_09", "MossBone Crawler (1)"), null, notSceneBundle: false, MiscFixers.AddComponent<EnemyFixers.Mossgrub>).WithReceiverGroup(ReceiverGroup.Wakeable).DoFlipX().WithRotationGroup(RotationGroup.Four)
				.WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wakeable);
			AddEnemy("Falling Mossgrub", "mossbone_crawler_summon", ("Weave_03", "Boss Scene/MossBone Crawler Summon"), null, notSceneBundle: false, delegate(GameObject o)
			{
				o.GetComponent<HealthManager>().hasSpecialDeath = false;
				tk2dSpriteAnimator component = o.GetComponent<tk2dSpriteAnimator>();
				component.defaultClipId = component.GetClipIdByName("SummonFall");
			}, delegate(GameObject o)
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(o, "Summon Control");
				fsm.GetState("Dormant").AddAction(delegate
				{
					fsm.SendEvent("SPAWN");
				}, 0, everyFrame: false);
				fsm.GetState("Position").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
			});
			AddEnemy("Massive Mossgrub", "mossbone_crawler_fat", ("Arborium_09", "MossBone Crawler Fat"));
			AddEnemy("Mossmir", "mossbone_fly", ("Arborium_04", "MossBone Fly (1)"));
			AddEnemy("Moss Mother", "moss_mother", ("Tut_03", "Black Thread States/Normal World/Battle Scene/Wave 1/Mossbone Mother"), null, notSceneBundle: false, null, EnemyFixers.FixMossMother).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.MossMother).WithBroadcasterGroup(BroadcasterGroup.SlamBosses).DoFlipX();
			Categories.Misc.Add(new PreloadObject("Moss Cocoon", "moss_cocoon", ("Tut_03", "Black Thread States/Normal World/Battle Scene/Trap Cocoons/MossBone Cocoon (7)"), null, null, delegate(GameObject o)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetScale2D(o.transform, Vector2.one);
				Extensions.SetRotation2D(o.transform, 0f);
			}).WithBroadcasterGroup(BroadcasterGroup.Killable));
			Categories.Misc.Add(new PreloadObject("Moss Ball", "moss_ball_break", ("Tut_02", "moss_ball_break (11)"), null, preloadAction: MiscFixers.FixRotation, postSpawnAction: MiscFixers.FixBreakable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BreakableDecor).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			AddEnemy("Aknid Hatchling", "grove_pilgrim_hatchling", ("localpoolprefabs_assets_areaclover.bundle", "Assets/Prefabs/Hornet Enemies/Aspid Hatchling.prefab"), null, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Aknids);
			AddEnemy("Aknid", "aspid_collector", ("Mosstown_01", "Black Thread States Thread Only Variant/Black Thread World/Aspid Collector"), null, notSceneBundle: false, null, EnemyFixers.FixAknid).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Aknid);
			AddEnemy("Aknid Mother", "grove_pilgrim", ("localpoolprefabs_assets_areadust.bundle", "Assets/Prefabs/Hornet Enemies/Grove Pilgrim Fly.prefab"), null, notSceneBundle: true, EnemyFixers.FixAknidMother).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.AknidMother).DoFlipX();
			GameObject silkAcidCloud = new GameObject("[Architect] Silk Acid Cloud");
			silkAcidCloud.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)silkAcidCloud);
			PlaceableObject silkAcid = Categories.Attacks.Add(new CustomObject("Silk Acid Cloud", "silk_acid", silkAcidCloud, "Appears when the 'Activate' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("silk_acid", (FilterMode)1, default(Vector4), 128f)).WithReceiverGroup(ReceiverGroup.SilkAcid).WithRotationGroup(RotationGroup.All).WithScaleAction(delegate(GameObject o, float s)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				Transform child = o.transform.GetChild(0);
				child.localScale *= s;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_areacloverareamoss", "Assets/Prefabs/Hornet Enemies/SilkAcid BurstCloud.prefab", delegate(GameObject o)
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				bool activeSelf = o.activeSelf;
				o.SetActive(false);
				GameObject val = Object.Instantiate<GameObject>(o, silkAcidCloud.transform);
				if (activeSelf)
				{
					o.SetActive(true);
				}
				silkAcid.Offset = ((Component)val.transform.GetChild(1)).transform.localPosition;
			}, notSceneBundle: true));
			Categories.Effects.Add(new PreloadObject("Dust Effect", "emerge_dust", ("Greymoor_13", "Pilgrim 03/Drop Dust"), "Appears when the 'Emit' trigger is run.", null, sprite: ResourceUtils.LoadSpriteResource("dust", (FilterMode)1, default(Vector4), 64f), preloadAction: MiscFixers.FixDust).WithReceiverGroup(ReceiverGroup.Dust).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Dust).WithBroadcasterGroup(BroadcasterGroup.Finishable));
			AddEnemy("Overgrown Pilgrim", "pilgrim_moss_spitter", ("Mosstown_01", "Black Thread States Thread Only Variant/Normal World/Pilgrim Moss Spitter"), null, notSceneBundle: false, MiscFixers.FixRotation);
			Categories.Attacks.Add(new PreloadObject("Moss Ball", "moss_ball", ("localpoolprefabs_assets_areamoss", "Assets/Prefabs/Enemies/Fungus 1 + 2/Grass Ball.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Attacks.Add(new PreloadObject("Aknid Glob", "aspid_glob", ("localpoolprefabs_assets_areamoss", "Assets/Prefabs/Hornet Enemies/Aspid Collector Glob.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			Categories.Attacks.Add(new PreloadObject("Aknid Bullet", "aspid_bullet", ("localpoolprefabs_assets_areacrawl", "Assets/Prefabs/Hornet Enemies/Aspid Bullet.prefab"), "Usually already landed by the time the room finishes loading.\nBest used with the Object Spawner.", null, null, preview: false, notSceneBundle: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Velocity).WithInputGroup(InputGroup.Velocity).WithReceiverGroup(ReceiverGroup.Velocity));
			AddEnemy("Pilgrim Groveller", "pilgrim_03", ("Mosstown_01", "Pilgrim 03 (1)")).DoFlipX();
			AddEnemy("Pilgrim Pouncer", "pilgrim_01", ("Mosstown_01", "Pilgrim 01")).DoFlipX();
			AddEnemy("Pilgrim Hornfly", "pilgrim_hornfly", ("Bone_East_14b", "Pilgrim 04"), null, notSceneBundle: false, MiscFixers.AddComponent<EnemyFixers.Hornfly>).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hornfly).DoFlipX();
			AddEnemy("Pilgrim Hulk", "pilgrim_hulk", ("Bone_East_14b", "Pilgrim 02 (1)")).DoFlipX();
			AddEnemy("Winged Pilgrim", "pilgrim_fly", ("Coral_32", "Black Thread States/Black Thread World/Black_Thread_Core/Enemy Group/Pilgrim Fly")).DoFlipX();
			AddEnemy("Elder Pilgrim", "elder_pilgrim", ("Bonegrave", "Pilgrim Groups/Group 1/Act3 Pilgrim 05"), null, notSceneBundle: false, EnemyFixers.FixElderPilgrim, EnemyFixers.FixBonegravePilgrim);
			AddEnemy("Pilgrim Guide", "pilgrim_guide", ("Bonegrave", "Pilgrim Groups/Group 2/Pilgrim StaffWielder"), null, notSceneBundle: false, EnemyFixers.KeepActive, EnemyFixers.FixBonegravePilgrim);
			AddEnemy("Covetous Pilgrim", "covetous_pilgrim", ("Bonegrave", "Pilgrim Groups/Rosary Pilgrim Scene/Rosary Pilgrim"));
			Categories.Misc.Add(new PreloadObject("Rosary Bead", "rosary", ("Bonegrave", "Pilgrim Groups/Rosary Pilgrim Scene/Geo Small Persistent (4)"), "Can be configured to be worth any number of rosaries\nand to use a Custom PNG texture.", null, delegate(GameObject o)
			{
				o.AddComponent<PngObject>();
			}).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.RosaryBead));
			AddEnemy("Pilgrim Hiker", "pilgrim_hiker", ("Coral_32", "Black Thread States/Black Thread World/Black_Thread_Core/Enemy Group/Pilgrim Hiker"));
			AddEnemy("Pilgrim Bellbearer", "pilgrim_bell", ("Greymoor_13", "Black Thread States Thread Only Variant/Normal World/Pilgrim BellThrower"), null, notSceneBundle: false, MiscFixers.FixRotation);
			AddEnemy("Winged Pilgrim Bellbearer", "pilgrim_wingbell", ("Greymoor_13", "Black Thread States Thread Only Variant/Black Thread World/Pilgrim Bellthrower Fly"), null, notSceneBundle: false, MiscFixers.FixRotation).DoFlipX();
			AddSolid("Moss Grotto Platform 1", "moss_plat_01", ("Weave_03", "bone_plat_01 (6)"));
			AddSolid("Moss Grotto Platform 2", "bone_plat_01", ("Tut_02", "bone_plat_01"));
			AddSolid("Moss Grotto Platform 3", "bone_plat_02", ("Tut_02", "bone_plat_02"));
			Categories.Interactable.Add(new PreloadObject("Pilgrim Trap Wire", "pilgrim_trap_wire", ("Mosstown_02", "Pilgrim Trap Wire"), null, InteractableFixers.FixTrapWire).DoFlipX().WithBroadcasterGroup(BroadcasterGroup.Activatable).WithRotationGroup(RotationGroup.All));
			Categories.Hazards.Add(new PreloadObject("Pilgrim Trap Spike", "pilgrim_trap_spike", ("Mosstown_02", "traps_left/Pilgrim Trap Spike"), "This spike starts hidden, the 'Activate' trigger will\ncause the spike to come out of the ground.").WithReceiverGroup(ReceiverGroup.Trap).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Hazards));
			Categories.Npcs.Add(new PreloadObject("Pilby NPC", "pilby_death", ("Bonetown", "Black Thread States/Normal World/Bonetown Resident"), null, preloadAction: EnemyFixers.KeepActive, postSpawnAction: MiscFixers.FixPilby)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs)
				.WithReceiverGroup(ReceiverGroup.Pilby);
			Categories.Npcs.Add(new PreloadObject("Flick NPC", "flick_npc", ("Bonetown", "Black Thread States/Normal World/RestBench Control/Bench Getting Repaired/Fixer Pilgrim Bench Repair"), null, MiscFixers.AddComponent<MiscFixers.Flick>)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Npcs).WithBroadcasterGroup(BroadcasterGroup.Npcs);
			Categories.Misc.Add(new PreloadObject("Egg Statue Front", "shard_statue_4", ("Tut_01b", "Shell Shard Fossil Tiny Front"), Settings.PrideMode ? "Still cis btw" : null, preloadAction: MiscFixers.FixRotation, postSpawnAction: MiscFixers.FixStatue).WithRotationGroup(RotationGroup.Eight).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Statue).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Egg Statue Side", "shard_statue_2", ("Coral_36", "Shell Shard Fossil Tiny Egg"), Settings.PrideMode ? "Still cis btw" : null, preloadAction: MiscFixers.FixRotation, postSpawnAction: MiscFixers.FixStatue).WithRotationGroup(RotationGroup.Eight).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Statue).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Pilgrim Statue", "shard_statue_5", ("Tut_01b", "Shell Shard Fossil Mid (1)"), null, preloadAction: MiscFixers.FixRotation, postSpawnAction: MiscFixers.FixStatue).WithRotationGroup(RotationGroup.Eight).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Statue).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Spiral Statue", "shard_statue_3", ("Bone_East_LavaChallenge", "Shell Shard Fossil Mid"), null, preloadAction: MiscFixers.FixRotation, postSpawnAction: MiscFixers.FixStatue).WithRotationGroup(RotationGroup.Eight).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Statue).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Marrowmaw Statue", "shard_statue_1", ("Coral_36", "Shell Shard Fossil Beast"), null, MiscFixers.FixStatue).WithRotationGroup(RotationGroup.Eight).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Statue).WithBroadcasterGroup(BroadcasterGroup.Breakable));
			Categories.Misc.Add(new PreloadObject("Fixer Statue", "flick_statue", ("Bonetown", "Black Thread States/Normal World/fixer_constructs/fixer_statue/Shell Shard Fossil Big"), null, MiscFixers.FixFixerStatue).WithRotationGroup(RotationGroup.Eight).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Statue).WithBroadcasterGroup(BroadcasterGroup.Breakable));
		}

		private static PlaceableObject AddEnemy(string name, string id, (string, string) path, string description = null, bool notSceneBundle = false, [CanBeNull] Action<GameObject> preloadAction = null, [CanBeNull] Action<GameObject> postSpawnAction = null)
		{
			Architect.Objects.Categories.Category enemies = Categories.Enemies;
			bool notSceneBundle2 = notSceneBundle;
			return enemies.Add(new PreloadObject(name, id, path, description, postSpawnAction, preloadAction, preview: false, notSceneBundle2).WithReceiverGroup(ReceiverGroup.Enemies).WithBroadcasterGroup(BroadcasterGroup.Enemies).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Enemies)
				.WithOutputGroup(OutputGroup.Enemies));
		}

		private static PlaceableObject AddSolid(string name, string id, (string, string) path, [CanBeNull] Action<GameObject> preloadAction = null)
		{
			return Categories.Solids.Add(new PreloadObject(name, id, path, null, delegate(GameObject o)
			{
				SpriteFlash val = o.AddComponent<SpriteFlash>();
				val.children = new List<SpriteFlash>();
				val.parents = new List<SpriteFlash>();
			}, preloadAction)).WithRotationGroup(RotationGroup.Four).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Colliders);
		}
	}
}
namespace Architect.Content.Preloads
{
	public class BasicPreload : IPreload
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Action<GameObject> <callback>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private bool <notSceneBundle>P;

		public bool Loaded { get; private set; }

		public string Scene { get; }

		public string Path { get; }

		public bool IsNotSceneBundle => <notSceneBundle>P;

		public bool ShouldAlwaysLoad => true;

		public BasicPreload(string scene, string path, Action<GameObject> callback, bool notSceneBundle = false)
		{
			<callback>P = callback;
			<notSceneBundle>P = notSceneBundle;
			Scene = scene;
			Path = path;
			base..ctor();
		}

		public void OnPreload(GameObject preload)
		{
			<callback>P(preload);
		}

		public void SetAsset(ManagedAsset<GameObject> asset)
		{
		}

		public void MarkLoaded()
		{
			Loaded = true;
		}
	}
	public interface IPreload
	{
		bool Loaded { get; }

		string Scene { get; }

		string Path { get; }

		bool IsNotSceneBundle { get; }

		bool ShouldAlwaysLoad { get; }

		void OnPreload(GameObject preload)
		{
		}

		void SetAsset(ManagedAsset<GameObject> asset);

		void MarkLoaded();
	}
	public static class PatchworkFix
	{
		public static void Init()
		{
			typeof(SpriteLoader).Hook("LoadCollection", (Action<Action<tk2dSpriteCollectionData>, tk2dSpriteCollectionData>)delegate(Action<tk2dSpriteCollectionData> orig, tk2dSpriteCollectionData self)
			{
				if (PreloadManager.HasPreloaded && !PreloadManager.IsLoading)
				{
					orig(self);
				}
			});
		}
	}
	public static class PreloadManager
	{
		[CompilerGenerated]
		private sealed class <Preload>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private List<(IPreload, ManagedAsset<GameObject>)>.Enumerator <>s__1;

			private IPreload <preload>5__2;

			private ManagedAsset<GameObject> <asset>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(List<(IPreload, ManagedAsset<GameObject>)>.Enumerator);
				<preload>5__2 = null;
				<asset>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Settings.LoadAllAssets.Value)
					{
						StorageManager.FindLoadRequirements();
					}
					_totalCount = Preloaded.Count(((IPreload, ManagedAsset<GameObject>) p) => p.Item1.ShouldAlwaysLoad);
					<>s__1 = Preloaded.GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							(<preload>5__2, <asset>5__3) = <>s__1.Current;
							if (!<preload>5__2.Loaded)
							{
								if (!<preload>5__2.ShouldAlwaysLoad)
								{
									<preload>5__2.SetAsset(<asset>5__3);
									continue;
								}
								<preload>5__2.MarkLoaded();
								((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Prepare(<preload>5__2, <asset>5__3));
								<preload>5__2 = null;
								<asset>5__3 = null;
							}
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(List<(IPreload, ManagedAsset<GameObject>)>.Enumerator);
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (_count < _totalCount)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				HasPreloaded = true;
				Object.Destroy((Object)(object)_canvasObj);
				WorkshopManager.Setup();
				CrestBinding.InitItcHook();
				FavouritesCategory.Favourites = StorageManager.LoadFavourites();
				SavedCategory.Objects = StorageManager.LoadSavedObjects();
				PrefabsCategory.Prefabs = StorageManager.LoadPrefabs(StorageManager.DataPath);
				return false;
			}

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

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

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

			private object <>2__current;

			public IPreload preload;

			public ManagedAsset<GameObject> asset;

			private GameObject <foundObject>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					asset.Load();
					<>2__current = asset.Handle;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (asset.Handle.OperationException != null)
					{
						return false;
					}
					<foundObject>5__1 = asset.Handle.Result;
					preload.OnPreload(<foundObject>5__1);
					_count++;
					_status.text = $"{_count} / {_totalCount}";
					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 static bool HasPreloaded;

		public static bool IsLoading;

		private static GameObject _canvasObj;

		private static Text _status;

		private static int _count;

		private static int _totalCount;

		private static readonly Dictionary<string, List<(string, IPreload)>> ToPreload = new Dictionary<string, List<(string, IPreload)>>();

		private static readonly List<(IPreload, ManagedAsset<GameObject>)> Preloaded = new List<(IPreload, ManagedAsset<GameObject>)>();

		public static void Init()
		{
			RegisterPreloads();
			AssetRequestAPI.InvokeAfterBundleCreation((Action)FinishPreloading);
		}

		private static void SetupCanvas()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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)
			_canvasObj = new GameObject("[Architect] Preload Status");
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			_canvasObj.AddComponent<Canvas>().renderMode = (RenderMode)0;
			CanvasScaler val = _canvasObj.AddComponent<CanvasScaler>();
			val.uiScaleMode = (ScaleMode)1;
			val.screenMatchMode = (ScreenMatchMode)1;
			_canvasObj.AddComponent<GraphicRaycaster>();
			UIUtils.MakeImage("Preload BG", _canvasObj, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(3000f, 3000f)).sprite = ResourceUtils.LoadSpriteResource("preloader_bg", (FilterMode)1);
			UIUtils.Label label = UIUtils.MakeLabel("Progress", _canvasObj, Vector2.zero, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), 80f, 80f, (HorizontalWrapMode)1);
			label.font = "TrajanPro-Bold";
			((Component)label).transform.SetAsLastSibling();
			_status = (Text)(object)label.textComponent;
			_status.alignment = (TextAnchor)1;
			_status.fontSize = 32;
		}

		private static void RegisterPreloads()
		{
			foreach (var (text2, list2) in ToPreload)
			{
				foreach (var item4 in list2)
				{
					string item = item4.Item1;
					IPreload item2 = item4.Item2;
					ManagedAsset<GameObject> item3 = (item2.IsNotSceneBundle ? ManagedAsset<GameObject>.FromNonSceneAsset(item, text2) : ManagedAsset<GameObject>.FromSceneAsset(text2, item));
					Preloaded.Add((item2, item3));
				}
			}
		}

		public static void FinishPreloading()
		{
			if (!HasPreloaded)
			{
				SetupCanvas();
				if (Chainloader.PluginInfos.ContainsKey("Patchwork"))
				{
					ArchitectPlugin.Logger.LogInfo((object)"Patchwork fix...");
					PatchworkFix.Init();
				}
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Preload());
			}
		}

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

		[IteratorStateMachine(typeof(<Prepare>d__13))]
		private static IEnumerator Prepare(IPreload preload, ManagedAsset<GameObject> asset)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Prepare>d__13(0)
			{
				preload = preload,
				asset = asset
			};
		}

		public static void RegisterPreload(IPreload obj)
		{
			if (!ToPreload.ContainsKey(obj.Scene))
			{
				ToPreload[obj.Scene] = new List<(string, IPreload)>();
			}
			ToPreload[obj.Scene].Add((obj.Path, obj));
		}
	}
}
namespace Architect.Content.Custom
{
	public static class AbilityObjects
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Predicate<Binding> <>9__15_0;

			public static Func<Binding, bool> <>9__15_1;

			public static Predicate<Binding> <>9__16_0;

			public static Func<Binding, bool> <>9__16_1;

			public static Predicate<Binding> <>9__17_0;

			public static Func<Binding, bool> <>9__17_1;

			public static Func<(string, Sprite), bool> <>9__19_0;

			public static Func<(string, int, Sprite), bool> <>9__20_0;

			public static PlayerDataVariableHandler<bool> <>9__21_0;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_1;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_2;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_3;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_4;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_5;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_6;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_7;

			public static Func<Func<HeroController, bool>, HeroController, bool> <>9__21_8;

			public static Action<Action<HeroController, AttackDirection>, HeroController, AttackDirection> <>9__21_9;

			public static Func<Func<PlayerData, int>, PlayerData, int> <>9__21_10;

			public static Func<Func<PlayerData, int>, PlayerData, int> <>9__21_11;

			public static Func<Func<HeroController, bool, bool>, HeroController, bool, bool> <>9__21_12;

			public static Action<Action<HeroController>, HeroController> <>9__21_13;

			public static Action<Action<HeroController>, HeroController> <>9__21_14;

			public static Func<Func<HeroController, bool, bool>, HeroController, bool, bool> <>9__21_15;

			public static Func<Instruction, bool> <>9__21_17;

			public static Manipulator <>9__21_16;

			public static Action <>9__23_3;

			public static Action <>9__23_4;

			public static Action<HeroController> <>9__23_0;

			public static Action<Action<HeroController>, HeroController> <>9__23_1;

			public static Action<PlayMakerFSM> <>9__23_2;

			internal bool <BindingCheck>b__15_0(Binding binding)
			{
				return !Object.op_Implicit((Object)(object)binding);
			}

			internal bool <BindingCheck>b__15_1(Binding binding)
			{
				return binding.active && ((Component)binding).gameObject.activeInHierarchy;
			}

			internal bool <VisibleBindingCheck>b__16_0(Binding binding)
			{
				return !Object.op_Implicit((Object)(object)binding);
			}

			internal bool <VisibleBindingCheck>b__16_1(Binding binding)
			{
				return binding.active && ((Component)binding).gameObject.activeInHierarchy;
			}

			internal bool <GetActiveCrestBinding>b__17_0(Binding binding)
			{
				return !Object.op_Implicit((Object)(object)binding);
			}

			internal bool <GetActiveCrestBinding>b__17_1(Binding binding)
			{
				return binding.active && ((Component)binding).gameObject.activeInHierarchy;
			}

			internal bool <RefreshBindingUI>b__19_0((string, Sprite) bind)
			{
				return !VisibleBindingCheck(bind.Item1);
			}

			internal bool <RefreshCrystalUI>b__20_0((string, int, Sprite) bind)
			{
				return ActiveCrystals.GetValueOrDefault(bind.Item1, 0) == bind.Item2;
			}

			internal bool <SetupBindingHooks>b__21_0(PlayerData pd, string name, bool current)
			{
				if (1 == 0)
				{
				}
				bool result = ((name == "hasDash") ? BindingCheck(current, "dash") : ((!(name == "hasWalljump")) ? current : BindingCheck(current, "wall_jump")));
				if (1 == 0)
				{
				}
				return result;
			}

			internal bool <SetupBindingHooks>b__21_1(Func<HeroController, bool> orig, HeroController self)
			{
				return BindingCheck(orig(self), "dash") || (ActiveCrystals.GetValueOrDefault("dash", 0) > 0 && ((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Dash).WasPressed);
			}

			internal bool <SetupBindingHooks>b__21_2(Func<HeroController, bool> orig, HeroController self)
			{
				return orig(self) && ActiveCrystals.GetValueOrDefault("dash", 0) <= 0;
			}

			internal bool <SetupBindingHooks>b__21_3(Func<HeroController, bool> orig, HeroController self)
			{
				return BindingCheck(orig(self), "dash") || ActiveCrystals.GetValueOrDefault("dash", 0) > 0;
			}

			internal bool <SetupBindingHooks>b__21_4(Func<HeroController, bool> orig, HeroController self)
			{
				return BindingCheck(orig(self), "harpoon") || ActiveCrystals.GetValueOrDefault("harpoon", 0) > 0;
			}

			internal bool <SetupBindingHooks>b__21_5(Func<HeroController, bool> orig, HeroController self)
			{
				return BindingCheck(orig(self), "jump");
			}

			internal bool <SetupBindingHooks>b__21_6(Func<HeroController, bool> orig, HeroController self)
			{
				return BindingCheck(orig(self), "needolin");
			}

			internal bool <SetupBindingHooks>b__21_7(Func<HeroController, bool> orig, HeroController self)
			{
				return BindingCheck(orig(self), "super_jump");
			}

			internal bool <SetupBindingHooks>b__21_8(Func<HeroController, bool> orig, HeroController self)
			{
				return BindingCheck(orig(self), "attack");
			}

			internal void <SetupBindingHooks>b__21_9(Action<HeroController, AttackDirection> orig, HeroController self, AttackDirection dir)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (BindingCheck(orig: true, "attack"))
				{
					orig(self, dir);
				}
			}

			internal int <SetupBindingHooks>b__21_10(Func<PlayerData, int> orig, PlayerData self)
			{
				return BindingCheck(orig: true, "needle") ? orig(self) : 5;
			}

			internal int <SetupBindingHooks>b__21_11(Func<PlayerData, int> orig, PlayerData self)
			{
				return BindingCheck(orig: true, "silk_heart") ? orig(self) : 0;
			}

			internal bool <SetupBindingHooks>b__21_12(Func<HeroController, bool, bool> orig, HeroController self, bool checkControlState)
			{
				return BindingCheck(orig(self, checkControlState), "double_jump") || (ActiveCrystals.GetValueOrDefault("wings", 0) > 0 && ((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Jump).WasPressed);
			}

			internal void <SetupBindingHooks>b__21_13(Action<HeroController> orig, HeroController self)
			{
				if (BindingCheck(orig: true, "drift"))
				{
					orig(self);
				}
			}

			internal void <SetupBindingHooks>b__21_14(Action<HeroController> orig, HeroController self)
			{
				if (BindingCheck(orig: true, "double_jump") && (ActiveCrystals.GetValueOrDefault("wings", 0) <= 0 || !((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Jump).WasPressed))
				{
					orig(self);
				}
			}

			internal bool <SetupBindingHooks>b__21_15(Func<HeroController, bool, bool> orig, HeroController self, bool checkControlState)
			{
				return BindingCheck(orig(self, checkControlState), "drift");
			}

			internal void <SetupBindingHooks>b__21_16(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction instr) => ILPatternMatchingExt.MatchStloc(instr, 1)
				}))
				{
					val.Emit(OpCodes.Call, (MethodBase)typeof(AbilityObjects).GetMethod("ShouldDisableFreezing"));
					val.Emit(OpCodes.Stloc_1);
				}
			}

			internal bool <SetupBindingHooks>b__21_17(Instruction instr)
			{
				return ILPatternMatchingExt.MatchStloc(instr, 1);
			}

			internal void <SetupCrystalHooks>b__23_0(HeroController self)
			{
				self.OnDoubleJumped += delegate
				{
					if (ActiveCrystals.ContainsKey("wings"))
					{
						ActiveCrystals["wings"]--;
						RefreshCrystalUI();
					}
				};
				self.OnHazardRespawn += delegate
				{
					ActiveCrystals.Clear();
					RefreshCrystalUI();
				};
			}

			internal void <SetupCrystalHooks>b__23_3()
			{
				if (ActiveCrystals.ContainsKey("wings"))
				{
					ActiveCrystals["wings"]--;
					RefreshCrystalUI();
				}
			}

			internal void <SetupCrystalHooks>b__23_4()
			{
				ActiveCrystals.Clear();
				RefreshCrystalUI();
			}

			internal void <SetupCrystalHooks>b__23_1(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				if (((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Dash).WasPressed && ActiveCrystals.ContainsKey("dash"))
				{
					ActiveCrystals["dash"]--;
					RefreshCrystalUI();
				}
			}

			internal void <SetupCrystalHooks>b__23_2(PlayMakerFSM fsm)
			{
				<>c__DisplayClass23_0 CS$<>8__locals0 = new <>c__DisplayClass23_0
				{
					fsm = fsm
				};
				<>c__DisplayClass23_1 CS$<>8__locals1 = new <>c__DisplayClass23_1();
				switch (CS$<>8__locals0.fsm.FsmName)
				{
				case "Harpoon Dash":
				{
					<>c__DisplayClass23_2 CS$<>8__locals2 = new <>c__DisplayClass23_2
					{
						silk = CS$<>8__locals0.fsm.FsmVariables.FindFsmInt("Current Silk")
					};
					CS$<>8__locals0.fsm.GetState("Can Do?").AddAction(delegate
					{
						if (ActiveCrystals.GetValueOrDefault("harpoon", 0) > 0)
						{
							ActiveCrystals["harpoon"]--;
							CS$<>8__locals2.silk.Value = 1;
							RefreshCrystalUI();
						}
					}, 2, everyFrame: false);
					break;
				}
				case "Sprint":
					CS$<>8__locals0.fsm.GetState("Dash Stab Dir").AddAction(delegate
					{
						if (!BindingCheck(orig: true, "attack"))
						{
							CS$<>8__locals0.fsm.SendEvent("DO SPRINT SKID");
						}
					}, 0, everyFrame: false);
					break;
				case "Umbrella Float":
					CS$<>8__locals0.fsm.fsmTemplate = null;
					CS$<>8__locals1.cd = CS$<>8__locals0.fsm.FsmVariables.FindFsmBool("Can Dash");
					CS$<>8__locals0.fsm.GetState("Float Idle").AddAction(delegate
					{
						if (ActiveCrystals.GetValueOrDefault("dash", 0) > 0)
						{
							CS$<>8__locals1.cd.Value = true;
						}
					}, 0, everyFrame: true);
					break;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass23_0
		{
			public PlayMakerFSM fsm;

			internal void <SetupCrystalHooks>b__5()
			{
				if (!BindingCheck(orig: true, "attack"))
				{
					fsm.SendEvent("DO SPRINT SKID");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass23_1
		{
			public FsmBool cd;

			internal void <SetupCrystalHooks>b__6()
			{
				if (ActiveCrystals.GetValueOrDefault("dash", 0) > 0)
				{
					cd.Value = true;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass23_2
		{
			public FsmInt silk;

			internal void <SetupCrystalHooks>b__7()
			{
				if (ActiveCrystals.GetValueOrDefault("harpoon", 0) > 0)
				{
					ActiveCrystals["harpoon"]--;
					silk.Value = 1;
					RefreshCrystalUI();
				}
			}
		}

		private static GameObject _canvasObj;

		internal static readonly Dictionary<string, List<Binding>> ActiveBindings = new Dictionary<string, List<Binding>>();

		internal static readonly Dictionary<string, List<Binding>> ActiveVisibleBindings = new Dictionary<string, List<Binding>>();

		internal static readonly Dictionary<string, int> ActiveCrystals = new Dictionary<string, int>();

		internal static readonly List<(string, Sprite)> Bindings = new List<(string, Sprite)>();

		internal static readonly List<(string, Sprite)> CrestBindings = new List<(string, Sprite)>();

		internal static readonly List<(string, int, Sprite)> Crystals = new List<(string, int, Sprite)>();

		internal static readonly List<Image> BindingIcons = new List<Image>();

		internal static readonly List<Image> CrystalIcons = new List<Image>();

		public static void Init()
		{
			AbilityCrystal.Init();
			MakeCrystals("Dash", "dash");
			MakeCrystals("Clawline", "harpoon");
			MakeCrystals("Double Jump", "wings");
			SetupCrystalHooks();
			Binding.Init();
			Categories.Abilities.Add(MakeAbilityBinding("Dash", "dash"));
			Categories.Abilities.Add(MakeAbilityBinding("Clawline", "harpoon"));
			Categories.Abilities.Add(MakeAbilityBinding("Wall Jump", "wall_jump"));
			Categories.Abilities.Add(MakeAbilityBinding("Silk Soar", "super_jump"));
			Categories.Abilities.Add(MakeAbilityBinding("Needolin", "needolin"));
			Categories.Abilities.Add(MakeAbilityBinding("Drift", "drift"));
			Categories.Abilities.Add(MakeAbilityBinding("Double Jump", "double_jump"));
			Categories.Abilities.Add(MakeAbilityBinding("Silk Heart", "silk_heart"));
			Categories.Abilities.Add(MakeAbilityBinding("Frost", "frost"));
			Categories.Abilities.Add(MakeAbilityBinding("Needle", "needle", "Locks the needle damage to 5\n\n"));
			Categories.Abilities.Add(MakeAbilityBinding("Attack", "attack"));
			SetupBindingHooks();
			CrestBinding.InitCrestBindings();
			Categories.Abilities.Add(MakeCrestBinding("Hunter", "hunter_crest", "Hunter"));
			Categories.Abilities.Add(MakeCrestBinding("Hunter v2", "hunter_2_crest", "Hunter_v2"));
			Categories.Abilities.Add(MakeCrestBinding("Hunter v3", "hunter_3_crest", "Hunter_v3"));
			Categories.Abilities.Add(MakeCrestBinding("Reaper", "reaper_crest", "Reaper"));
			Categories.Abilities.Add(MakeCrestBinding("Wanderer", "wanderer_crest", "Wanderer"));
			Categories.Abilities.Add(MakeCrestBinding("Beast", "beast_crest", "Warrior"));
			Categories.Abilities.Add(MakeCrestBinding("Witch", "witch_crest", "Witch"));
			Categories.Abilities.Add(MakeCrestBinding("Architect", "architect_crest", "Toolmaster"));
			Categories.Abilities.Add(MakeCrestBinding("Shaman", "shaman_crest", "Spell"));
			Categories.Abilities.Add(MakeCrestBinding("Cursed", "cursed_crest", "Cursed"));
			Categories.Abilities.Add(MakeCrestBinding("Cloakless", "cloakless_crest", "Cloakless"));
			SetupVisuals();
		}

		public static void Update()
		{
			if (Object.op_Implicit((Object)(object)GameManager.SilentInstance))
			{
				_canvasObj.SetActive(!GameManager.SilentInstance.isPaused && GameManager.SilentInstance.IsGameplayScene() && !EditManager.IsEditing);
			}
		}

		private static void MakeCrystals(string name, string id)
		{
			MakeCrystal(name + " Crystal", id, "Crystals." + id + "_s", 1);
			MakeCrystal("Double " + name + " Crystal", id, "Crystals." + id + "_m", 2);
			MakeCrystal("Triple " + name + " Crystal", id, "Crystals." + id + "_l", 3);
		}

		private static void MakeCrystal(string name, string id, string spriteTexture, int count)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			CircleCollider2D val2 = val.AddComponent<CircleCollider2D>();
			val2.radius = 0.48f;
			((Collider2D)val2).isTrigger = true;
			((Collider2D)val2).offset = new Vector2(0f, -0.1f * (float)(3 - count));
			Sprite val3 = ResourceUtils.LoadSpriteResource(spriteTexture, (FilterMode)0, default(Vector4), 15f);
			val.transform.position = new Vector3(0f, 0f, 0.005f);
			GameObject val4 = new GameObject("Sprite");
			val4.transform.SetParent(val.transform, false);
			val4.AddComponent<SpriteRenderer>().sprite = val3;
			val4.AddComponent<FloatAnim>();
			AbilityCrystal abilityCrystal = val.AddComponent<AbilityCrystal>();
			abilityCrystal.type = id;
			abilityCrystal.count = count;
			Crystals.Add((id, count, val3));
			Categories.Abilities.Add(new CustomObject(name, $"{id}_{count}", val, "Lets the player use an ability a limited number of times without needing to unlock it.\n\nCan also be used to refresh abilities midair or without silk.\n\nAbility crystals override any active bindings.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.AbilityCrystal).WithBroadcasterGroup(BroadcasterGroup.AbilityCrystal).WithReceiverGroup(ReceiverGroup.AbilityCrystal));
		}

		private static PlaceableObject MakeAbilityBinding(string name, string id, string overrideDesc = null)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0036: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name + " Binding");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.transform.position = new Vector3(0f, 0f, 0.005f);
			Binding binding = val.AddComponent<Binding>();
			binding.bindingType = id;
			Sprite val2 = (binding.enabledSprite = ResourceUtils.LoadSpriteResource("Bindings." + id + "_enabled", (FilterMode)1));
			binding.disabledSprite = ResourceUtils.LoadSpriteResource("Bindings." + id + "_disabled", (FilterMode)1);
			val.AddComponent<SpriteRenderer>().sprite = val2;
			Bindings.Add((id, val2));
			CircleCollider2D val3 = val.AddComponent<CircleCollider2D>();
			((Collider2D)val3).isTrigger = true;
			val3.radius = 0.65f;
			return new CustomObject(name + " Binding", id + "_binding", val, (overrideDesc ?? "Temporarily disables a skill. Touching the binding will toggle it.\n\n") + "Bindings are active by default, set 'Binding Active' to false\nfor a binding the player must touch to enable.\n\nSet 'Reversible' to true to allow the player to toggle the binding multiple times.").WithBroadcasterGroup(BroadcasterGroup.Bindings).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bindings);
		}

		private static PlaceableObject MakeCrestBinding(string name, string id, string crestId)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0036: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name + " Crest Binding");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.transform.position = new Vector3(0f, 0f, 0.005f);
			CrestBinding crestBinding = val.AddComponent<CrestBinding>();
			crestBinding.bindingType = crestId;
			Sprite val2 = (crestBinding.enabledSprite = ResourceUtils.LoadSpriteResource("Bindings." + id + "_enabled", (FilterMode)1));
			crestBinding.disabledSprite = ResourceUtils.LoadSpriteResource("Bindings." + id + "_disabled", (FilterMode)1);
			val.AddComponent<SpriteRenderer>().sprite = val2;
			CrestBindings.Add((crestId, val2));
			CircleCollider2D val3 = val.AddComponent<CircleCollider2D>();
			((Collider2D)val3).isTrigger = true;
			val3.radius = 0.65f;
			return new CustomObject(name + " Binding", id + "_binding", val, "Locks the player to this crest when the binding is active.\nIf multiple crest bindings are placed, the crest with the most bindings will be the active crest.\n\nTouching the binding will toggle it. 'Binding Active' determines whether it starts on.\nEnable 'Reversible' to allow the binding to be toggled on and off multiple times.").WithBroadcasterGroup(BroadcasterGroup.Bindings).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bindings);
		}

		private static bool BindingCheck(bool orig, string type)
		{
			if (!orig)
			{
				return false;
			}
			if (!ActiveBindings.TryGetValue(type, out var value) || value.Count == 0)
			{
				return true;
			}
			value.RemoveAll((Binding binding) => !Object.op_Implicit((Object)(object)binding));
			return value.Count((Binding binding) => binding.active && ((Component)binding).gameObject.activeInHierarchy) == 0;
		}

		private static bool VisibleBindingCheck(string type)
		{
			if (!ActiveVisibleBindings.TryGetValue(type, out var value) || value.Count == 0)
			{
				return true;
			}
			value.RemoveAll((Binding binding) => !Object.op_Implicit((Object)(object)binding));
			return value.Count((Binding binding) => binding.active && ((Component)binding).gameObject.activeInHierarchy) == 0;
		}

		public static (string, Sprite)? GetActiveCrestBinding()
		{
			int num = 0;
			(string, Sprite)? result = null;
			foreach (var crestBinding in CrestBindings)
			{
				if (ActiveBindings.TryGetValue(crestBinding.Item1, out var value))
				{
					value.RemoveAll((Binding binding) => !Object.op_Implicit((Object)(object)binding));
					int num2 = value.Count((Binding binding) => binding.active && ((Component)binding).gameObject.activeInHierarchy);
					if (num2 > num)
					{
						num = num2;
						result = crestBinding;
					}
				}
			}
			return result;
		}

		private static void SetupVisuals()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			_canvasObj = new GameObject("[Architect] Ability Canvas");
			_canvasObj.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			_canvasObj.AddComponent<Canvas>().renderMode = (RenderMode)0;
			CanvasScaler val = _canvasObj.AddComponent<CanvasScaler>();
			val.uiScaleMode = (ScaleMode)1;
			val.screenMatchMode = (ScreenMatchMode)1;
			_canvasObj.AddComponent<GraphicRaycaster>();
			for (int i = 0; i <= Bindings.Count; i++)
			{
				BindingIcons.Add(UIUtils.MakeImage($"Binding Icon {i}", _canvasObj, new Vector2((float)(26 * i + 22), 22f), Vector2.zero, Vector2.zero, new Vector2(45f, 45f)));
			}
			for (int j = 0; j < Crystals.Count / 3; j++)
			{
				Image val2 = UIUtils.MakeImage($"Crystal Icon {j}", _canvasObj, new Vector2((float)(18 * j + 22), -22f), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(45f, 45f));
				val2.preserveAspect = true;
				CrystalIcons.Add(val2);
			}
			RefreshBindingUI();
			RefreshCrystalUI();
		}

		public static void RefreshBindingUI()
		{
			int i = 0;
			foreach (var item in Bindings.Where(((string, Sprite) bind) => !VisibleBindingCheck(bind.Item1)))
			{
				BindingIcons[i].sprite = item.Item2;
				i++;
			}
			(string, Sprite)? activeCrestBinding = GetActiveCrestBinding();
			if (activeCrestBinding.HasValue && !VisibleBindingCheck(activeCrestBinding.Value.Item1))
			{
				BindingIcons[i].sprite = activeCrestBinding.Value.Item2;
				i++;
			}
			for (; i <= Bindings.Count; i++)
			{
				BindingIcons[i].sprite = ArchitectPlugin.BlankSprite;
			}
		}

		public static void RefreshCrystalUI()
		{
			int num = 0;
			foreach (var item in Crystals.Where(((string, int, Sprite) bind) => ActiveCrystals.GetValueOrDefault(bind.Item1, 0) == bind.Item2))
			{
				CrystalIcons[num].sprite = item.Item3;
				num++;
			}
			for (int i = num; i < Crystals.Count / 3; i++)
			{
				CrystalIcons[i].sprite = ArchitectPlugin.BlankSprite;
			}
		}

		private static void SetupBindingHooks()
		{
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Expected O, but got Unknown
			PlayerDataVariableEvents.OnGetBool += delegate(PlayerData pd, string name, bool current)
			{
				if (1 == 0)
				{
				}
				bool result = ((name == "hasDash") ? BindingCheck(current, "dash") : ((!(name == "hasWalljump")) ? current : BindingCheck(current, "wall_jump")));
				if (1 == 0)
				{
				}
				return result;
			};
			typeof(HeroController).Hook("CanDash", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => BindingCheck(orig(self), "dash") || (ActiveCrystals.GetValueOrDefault("dash", 0) > 0 && ((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Dash).WasPressed)));
			typeof(HeroController).Hook("GetAirdashed", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => orig(self) && ActiveCrystals.GetValueOrDefault("dash", 0) <= 0));
			typeof(HeroController).Hook("GetCanAirDashCancel", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => BindingCheck(orig(self), "dash") || ActiveCrystals.GetValueOrDefault("dash", 0) > 0));
			typeof(HeroController).Hook("CanHarpoonDash", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => BindingCheck(orig(self), "harpoon") || ActiveCrystals.GetValueOrDefault("harpoon", 0) > 0));
			typeof(HeroController).Hook("CanJump", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => BindingCheck(orig(self), "jump")));
			typeof(HeroController).Hook("CanPlayNeedolin", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => BindingCheck(orig(self), "needolin")));
			typeof(HeroController).Hook("CanSuperJump", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => BindingCheck(orig(self), "super_jump")));
			typeof(HeroController).Hook("CanNailCharge", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => BindingCheck(orig(self), "attack")));
			typeof(HeroController).Hook("Attack", (Action<Action<HeroController, AttackDirection>, HeroController, AttackDirection>)delegate(Action<HeroController, AttackDirection> orig, HeroController self, AttackDirection dir)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (BindingCheck(orig: true, "attack"))
				{
					orig(self, dir);
				}
			});
			new Hook((MethodBase)typeof(PlayerData).GetProperty("nailDamage").GetGetMethod(), (Delegate)(Func<Func<PlayerData, int>, PlayerData, int>)((Func<PlayerData, int> orig, PlayerData self) => BindingCheck(orig: true, "needle") ? orig(self) : 5));
			new Hook((MethodBase)typeof(PlayerData).GetProperty("CurrentSilkRegenMax").GetGetMethod(), (Delegate)(Func<Func<PlayerData, int>, PlayerData, int>)((Func<PlayerData, int> orig, PlayerData self) => BindingCheck(orig: true, "silk_heart") ? orig(self) : 0));
			typeof(HeroController).Hook("CanDoubleJump", (Func<Func<HeroController, bool, bool>, HeroController, bool, bool>)((Func<HeroController, bool, bool> orig, HeroController self, bool checkControlState) => BindingCheck(orig(self, checkControlState), "double_jump") || (ActiveCrystals.GetValueOrDefault("wings", 0) > 0 && ((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Jump).WasPressed)));
			typeof(HeroController).Hook("SetStartWithBrolly", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				if (BindingCheck(orig: true, "drift"))
				{
					orig(self);
				}
			});
			typeof(HeroController).Hook("SetStartWithDoubleJump", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				if (BindingCheck(orig: true, "double_jump") && (ActiveCrystals.GetValueOrDefault("wings", 0) <= 0 || !((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Jump).WasPressed))
				{
					orig(self);
				}
			});
			typeof(HeroController).Hook("CanFloat", (Func<Func<HeroController, bool, bool>, HeroController, bool, bool>)((Func<HeroController, bool, bool> orig, HeroController self, bool checkControlState) => BindingCheck(orig(self, checkControlState), "drift")));
			MethodInfo? method = typeof(HeroController).GetMethod("TickFrostEffect", BindingFlags.Instance | BindingFlags.NonPublic);
			object obj = <>c.<>9__21_16;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_0041: Unknown result type (might be due to invalid IL or missing references)
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val2 = new ILCursor(il);
					if (val2.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
					{
						(Instruction instr) => ILPatternMatchingExt.MatchStloc(instr, 1)
					}))
					{
						val2.Emit(OpCodes.Call, (MethodBase)typeof(AbilityObjects).GetMethod("ShouldDisableFreezing"));
						val2.Emit(OpCodes.Stloc_1);
					}
				};
				<>c.<>9__21_16 = val;
				obj = (object)val;
			}
			new ILHook((MethodBase)method, (Manipulator)obj);
		}

		public static bool ShouldDisableFreezing()
		{
			return BindingCheck(PlayerData.instance.hasDoubleJump, "frost");
		}

		private static void SetupCrystalHooks()
		{
			HookUtils.OnHeroAwake = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroAwake, (Action<HeroController>)delegate(HeroController self)
			{
				self.OnDoubleJumped += delegate
				{
					if (ActiveCrystals.ContainsKey("wings"))
					{
						ActiveCrystals["wings"]--;
						RefreshCrystalUI();
					}
				};
				self.OnHazardRespawn += delegate
				{
					ActiveCrystals.Clear();
					RefreshCrystalUI();
				};
			});
			typeof(HeroController).Hook("HeroDashPressed", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				if (((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Dash).WasPressed && ActiveCrystals.ContainsKey("dash"))
				{
					ActiveCrystals["dash"]--;
					RefreshCrystalUI();
				}
			});
			HookUtils.OnFsmAwake = (Action<PlayMakerFSM>)Delegate.Combine(HookUtils.OnFsmAwake, (Action<PlayMakerFSM>)delegate(PlayMakerFSM fsm)
			{
				switch (fsm.FsmName)
				{
				case "Harpoon Dash":
				{
					FsmInt silk = fsm.FsmVariables.FindFsmInt("Current Silk");
					fsm.GetState("Can Do?").AddAction(delegate
					{
						if (ActiveCrystals.GetValueOrDefault("harpoon", 0) > 0)
						{
							ActiveCrystals["harpoon"]--;
							silk.Value = 1;
							RefreshCrystalUI();
						}
					}, 2, everyFrame: false);
					break;
				}
				case "Sprint":
					fsm.GetState("Dash Stab Dir").AddAction(delegate
					{
						if (!BindingCheck(orig: true, "attack"))
						{
							fsm.SendEvent("DO SPRINT SKID");
						}
					}, 0, everyFrame: false);
					break;
				case "Umbrella Float":
				{
					fsm.fsmTemplate = null;
					FsmBool cd = fsm.FsmVariables.FindFsmBool("Can Dash");
					fsm.GetState("Float Idle").AddAction(delegate
					{
						if (ActiveCrystals.GetValueOrDefault("dash", 0) > 0)
						{
							cd.Value = true;
						}
					}, 0, everyFrame: true);
					break;
				}
				}
			});
		}
	}
	public static class CameraObjects
	{
		public class CustomCamera : MonoBehaviour
		{
			public string id;

			public int resolution = 1024;

			private bool _setup;

			private RenderTexture _rt;

			private Camera _camera;

			private ColorCorrectionCurves _ccc;

			private ColorCorrectionCurves _accc;

			private void Start()
			{
				_camera = ((Component)this).GetComponent<Camera>();
				_ccc = ((Component)this).GetComponent<ColorCorrectionCurves>();
				_accc = ((Component)GameCameras.instance.tk2dCam).GetComponent<ColorCorrectionCurves>();
			}

			private void Update()
			{
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Expected O, but got Unknown
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Expected O, but got Unknown
				_ccc.saturation = _accc.saturation;
				_ccc.blueChannel = _accc.blueChannel;
				_ccc.redChannel = _accc.redChannel;
				_ccc.greenChannel = _accc.greenChannel;
				RgbChannelTex.SetValue(_ccc, RgbChannelTex.GetValue(_accc));
				if (_setup)
				{
					return;
				}
				_setup = true;
				if (Utility.IsNullOrWhiteSpace(id) || !PlacementManager.Objects.TryGetValue(id, out var value))
				{
					((Component)this).gameObject.SetActive(false);
					return;
				}
				MeshRenderer component = value.GetComponent<MeshRenderer>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					((Component)this).gameObject.SetActive(false);
					return;
				}
				float scaleX = Extensions.GetScaleX(value.transform);
				float scaleY = Extensions.GetScaleY(value.transform);
				int num;
				int num2;
				if (scaleX > scaleY)
				{
					num = resolution;
					num2 = Math.Abs(Mathf.FloorToInt(scaleY / scaleX * (float)resolution));
				}
				else
				{
					num2 = resolution;
					num = Math.Abs(Mathf.FloorToInt(scaleX / scaleY * (float)resolution));
				}
				RenderTexture rt = new RenderTexture(num, num2, 64, (RenderTextureFormat)10)
				{
					name = "[Architect] Camera Target Texture"
				};
				Material val = new Material(Shader.Find("Sprites/Default"));
				RenderTexture mainTexture = (_camera.targetTexture = (_rt = rt));
				val.mainTexture = (Texture)(object)mainTexture;
				((Renderer)component).sharedMaterial = val;
				((Behaviour)_camera).enabled = true;
			}

			private void OnDestroy()
			{
				Object.Destroy((Object)(object)_rt);
			}
		}

		public class CustomCameraTarget : MonoBehaviour
		{
			public bool onUI;

			public float xOffset;

			public float yOffset;

			public int anchorTo;

			private static readonly int UILayer = LayerMask.NameToLayer("UI");

			private PositionConstraint _constraint;

			private MeshRenderer _mr;

			private static readonly List<CustomCameraTarget> Pngs = new List<CustomCameraTarget>();

			public bool ignoreHudOut;

			private static bool _hudOut;

			public static void InitTarget()
			{
				typeof(GameCameras).Hook("HUDIn", (Action<Action<GameCameras>, GameCameras>)delegate(Action<GameCameras> orig, GameCameras self)
				{
					_hudOut = false;
					Pngs.RemoveAll((CustomCameraTarget png) => !Object.op_Implicit((Object)(object)png));
					foreach (CustomCameraTarget item in Pngs.Where((CustomCameraTarget png) => Object.op_Implicit((Object)(object)png._constraint) && png.ignoreHudOut))
					{
						item._constraint.constraintActive = true;
					}
					orig(self);
				});
				typeof(GameCameras).Hook("HUDOut", (Action<Action<GameCameras>, GameCameras>)delegate(Action<GameCameras> orig, GameCameras self)
				{
					_hudOut = true;
					Pngs.RemoveAll((CustomCameraTarget png) => !Object.op_Implicit((Object)(object)png));
					foreach (CustomCameraTarget item2 in Pngs.Where((CustomCameraTarget png) => Object.op_Implicit((Object)(object)png._constraint) && png.ignoreHudOut))
					{
						item2._constraint.constraintActive = false;
					}
					orig(self);
				});
			}

			public void Start()
			{
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				if (onUI)
				{
					((Component)this).gameObject.layer = UILayer;
					((Component)((Component)this).gameObject.transform.GetChild(0)).gameObject.layer = UILayer;
					Transform sourceTransform = ((Component)GameCameras.instance.hudCamera).transform.Find("In-game").Find("Anchor TL").Find("Hud Canvas Offset")
						.Find("Hud Canvas");
					_constraint = ((Component)this).gameObject.AddComponent<PositionConstraint>();
					Pngs.Add(this);
					_constraint.constraintActive = true;
					ConstraintSource val = default(ConstraintSource);
					((ConstraintSource)(ref val)).sourceTransform = sourceTransform;
					((ConstraintSource)(ref val)).weight = 1f;
					ConstraintSource val2 = val;
					_constraint.AddSource(val2);
					_mr = ((Component)this).GetComponent<MeshRenderer>();
					((Renderer)_mr).sortingLayerName = "Over";
					UpdatePos();
					if (_hudOut && Object.op_Implicit((Object)(object)_constraint))
					{
						_constraint.constraintActive = false;
						((Component)this).transform.position = new Vector3(-10.3535f, 7.533f, 38.1f) + _constraint.translationOffset;
					}
				}
			}

			private void OnEnable()
			{
				if (onUI)
				{
					Extensions.AddIfNotPresent<CustomCameraTarget>(Pngs, this);
					if (_hudOut && Object.op_Implicit((Object)(object)_constraint))
					{
						_constraint.constraintActive = false;
					}
				}
			}

			private void UpdatePos()
			{
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				if (!onUI)
				{
					return;
				}
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(xOffset + 10.3535f, yOffset - 6.81f);
				switch (anchorTo)
				{
				case 1:
					val.x += 0.94f * (float)PlayerData.instance.maxHealth;
					break;
				case 2:
				{
					if (!Object.op_Implicit((Object)(object)ManagerSingleton<ToolItemManager>.Instance) || ManagerSingleton<ToolItemManager>.Instance.boundAttackTools == null)
					{
						return;
					}
					Transform val2 = ((Component)GameCameras.instance.hudCamera).transform.Find("In-game").Find("Anchor TL").Find("Hud Canvas Offset")
						.Find("Hud Canvas");
					Transform val3 = val2.Find("Tool Icons");
					val.x += 1.02f * (float)ManagerSingleton<ToolItemManager>.Instance.boundAttackTools.Count((ToolItem o) => Object.op_Implicit((Object)(object)o)) + Extensions.GetPositionX(((Component)val3).transform);
					break;
				}
				}
				_constraint.translationOffset = Vector2.op_Implicit(val);
			}

			private void LateUpdate()
			{
				if (onUI && anchorTo != 0)
				{
					UpdatePos();
				}
			}
		}

		private static readonly FieldInfo RgbChannelTex = typeof(ColorCorrectionCurves).GetField("rgbChannelTex", BindingFlags.Instance | BindingFlags.NonPublic);

		public static void Init()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			CustomCameraTarget.InitTarget();
			PreloadManager.RegisterPreload(new BasicPreload("coremanagers_assets__gamecameras", "Assets/Prefabs/Camera/_GameCameras.prefab", delegate(GameObject o)
			{
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				GameObject gameObject = ((Component)o.transform.GetChild(1).GetChild(0)).gameObject;
				gameObject.SetActive(false);
				GameObject val6 = Object.Instantiate<GameObject>(gameObject);
				Object.DontDestroyOnLoad((Object)(object)val6);
				val6.RemoveComponent<CameraController>();
				val6.RemoveComponent<AudioListener>();
				val6.RemoveComponent<FastNoise>();
				val6.RemoveComponent<NewCameraNoise>();
				val6.RemoveComponent<ForceCameraAspect>();
				val6.RemoveComponent<CameraRenderScaled>();
				val6.RemoveComponent<CameraRenderHooks>();
				val6.RemoveComponent<CameraShakeManager>();
				val6.AddComponent<CustomCamera>();
				Extensions.SetPositionZ(val6.transform, 0f);
				gameObject.SetActive(true);
				Object.Destroy((Object)(object)((Component)val6.transform.GetChild(4)).gameObject);
				Categories.Utility.AddStart(new CustomObject("Camera", "camera_object", val6, "An extra camera that can be rendered using a Camera View.", delegate(GameObject c)
				{
					Extensions.SetPositionZ(c.transform, -38.1f);
				}, preview: false, ResourceUtils.LoadSpriteResource("camera", (FilterMode)1)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Camera));
			}, notSceneBundle: true));
			GameObject val = new GameObject("[Architect] Camera View");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			GameObject val2 = new GameObject("Backing");
			val2.transform.parent = val.transform;
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localScale = Vector2.op_Implicit(new Vector2(0.5f, 0.5f));
			GameObject val3 = val2;
			SpriteRenderer val4 = val3.AddComponent<SpriteRenderer>();
			val4.color = Color.black;
			val4.sprite = UIUtils.Square;
			val.AddComponent<CustomCameraTarget>();
			val.AddComponent<MeshRenderer>();
			Mesh val5 = new Mesh();
			val5.vertices = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(-2.5f, -2.5f, 0f),
				new Vector3(2.5f, -2.5f, 0f),
				new Vector3(-2.5f, 2.5f, 0f),
				new Vector3(2.5f, 2.5f, 0f)
			};
			val5.triangles = new int[6] { 0, 2, 1, 2, 3, 1 };
			val5.normals = (Vector3[])(object)new Vector3[4]
			{
				-Vector3.forward,
				-Vector3.forward,
				-Vector3.forward,
				-Vector3.forward
			};
			val5.uv = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(0f, 0f),
				new Vector2(1f, 0f),
				new Vector2(0f, 1f),
				new Vector2(1f, 1f)
			};
			Mesh mesh = val5;
			val.AddComponent<MeshFilter>().mesh = mesh;
			Categories.Utility.AddStart(new CustomObject("Camera View", "camera_view", val, "Renders the view of an extra camera.", null, preview: false, ResourceUtils.LoadSpriteResource("camera_view", (FilterMode)0, default(Vector4), 40f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CameraView).DoIgnoreScale());
			typeof(ColorCorrectionCurves).Hook("OnDestroy", (Action<Action<ColorCorrectionCurves>, ColorCorrectionCurves>)delegate(Action<ColorCorrectionCurves> orig, ColorCorrectionCurves self)
			{
				if (Object.op_Implicit((Object)(object)((Component)self).GetComponent<CustomCamera>()))
				{
					RgbChannelTex.SetValue(self, null);
				}
				orig(self);
			});
		}
	}
	public static class CollectableObjects
	{
		public class CherryAnim : MonoBehaviour
		{
			public Sprite[] sprites;

			public int spriteIndex;

			private float _time;

			private SpriteRenderer _sr;

			private void Start()
			{
				_sr = ((Component)this).GetComponent<SpriteRenderer>();
			}

			private void Update()
			{
				_time += Time.deltaTime * 10f;
				while (_time > 1f)
				{
					_time -= 1f;
					spriteIndex++;
					spriteIndex %= sprites.Length;
					_sr.sprite = sprites[spriteIndex];
				}
				Extensions.SetLocalPositionY(((Component)this).transform, (1f - Mathf.Sin(MathF.PI * 2f * ((float)spriteIndex + _time - 8f) / 9f)) / 3f);
			}
		}

		public static void Init()
		{
			Categories.Abilities.Add(MakeCherry("Cherry", "Cherries.Normal.normal", 1, wing: false, ding: false));
			Categories.Abilities.Add(MakeCherry("Winged Cherry", "Cherries.Normal.wing", 9, wing: true, ding: false));
			Categories.Abilities.Add(MakeCherry("Golden Cherry", "Cherries.Ding.normal", 1, wing: false, ding: true));
			Categories.Abilities.Add(MakeCherry("Golden Winged Cherry", "Cherries.Ding.wing", 9, wing: true, ding: true));
		}

		private static PlaceableObject MakeCherry(string name, string path, int amount, bool wing, bool ding)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Cherry");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			Extensions.SetPositionZ(val.transform, 0.006f);
			GameObject val2 = new GameObject("Sprite");
			val2.transform.parent = val.transform;
			val2.transform.localPosition = Vector3.zero;
			GameObject val3 = val2;
			Sprite[] array = (Sprite[])(object)new Sprite[amount];
			for (int i = 0; i < amount; i++)
			{
				array[i] = ResourceUtils.LoadSpriteResource($"{path}{i + 1}", (FilterMode)0, default(Vector4), 15f);
			}
			val3.AddComponent<SpriteRenderer>().sprite = array[0];
			if (array.Length > 1)
			{
				val3.AddComponent<CherryAnim>().sprites = array;
			}
			else
			{
				val3.AddComponent<FloatAnim>();
			}
			return new CustomObject(name, $"cherry_{ding}_{wing}", val);
		}
	}
	public static class LegacyObjects
	{
		public static void Init()
		{
			Categories.Legacy.Add(CreateTimer());
			Categories.Legacy.Add(CreateKeyListener());
			Categories.Legacy.Add(CreateRelay());
			Categories.Legacy.Add(CreateTimeSlower());
			Categories.Legacy.Add(CreateAnimatorController());
			Categories.Legacy.Add(CreateTitleDisplay());
			Categories.Legacy.Add(CreateTextDisplay());
			Categories.Legacy.Add(CreateChoiceDisplay());
			Categories.Legacy.Add(CreatePlayerHook());
			Categories.Legacy.Add(CreatePlayerDataSetter());
			Categories.Legacy.Add(CreateCameraShaker());
		}

		private static PlaceableObject CreateTimer()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Timer");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<Timer>();
			return new CustomObject("Timer", "timer", val, "[LEGACY]\n\nBroadcasts an event periodically.", null, preview: false, ResourceUtils.LoadSpriteResource("timer", (FilterMode)0, default(Vector4), 10f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Timer).WithBroadcasterGroup(BroadcasterGroup.Callable).WithReceiverGroup(ReceiverGroup.Generic);
		}

		private static PlaceableObject CreateTitleDisplay()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Title Display");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<TitleDisplay>();
			return new CustomObject("Title Display", "title_display", val, "[LEGACY]\n\nUsed to display a title to the player, such as area or boss titles.", null, preview: false, ResourceUtils.LoadSpriteResource("title_display", (FilterMode)0, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.Displayable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.TitleDisplay);
		}

		private static PlaceableObject CreateTextDisplay()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Text Display");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<TextDisplay>();
			return new CustomObject("Text Display", "text_display", val, "[LEGACY]\n\nDisplays a piece of text.", null, preview: false, ResourceUtils.LoadSpriteResource("text_display", (FilterMode)0, default(Vector4), 10f)).WithReceiverGroup(ReceiverGroup.Displayable).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.TextDisplay).WithBroadcasterGroup(BroadcasterGroup.TextDisplay);
		}

		private static PlaceableObject CreateChoiceDisplay()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Choice Display");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<ChoiceDisplay>();
			return new CustomObject("Choice Display", "choice_display", val, "[LEGACY]\n\nDisplays a piece of text and prompts the player to choose Yes or No.", null, preview: false, ResourceUtils.LoadSpriteResource("choice_display", (FilterMode)0, default(Vector4), 10f)).WithReceiverGroup(ReceiverGroup.Displayable).WithBroadcasterGroup(BroadcasterGroup.Choice).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Choice);
		}

		private static PlaceableObject CreatePlayerHook()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Player Hook");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			PlayerHook.Init();
			val.AddComponent<PlayerHook>();
			return new CustomObject("Player Hook", "player_hook", val, "[LEGACY]\n\nCan detect certain inputs or actions from the player such as jumping or landing,\nand perform certain triggers such as damaging or killing the player.", null, preview: false, ResourceUtils.LoadSpriteResource("player_listener", (FilterMode)0, default(Vector4), 64f)).WithBroadcasterGroup(BroadcasterGroup.PlayerHooks).WithReceiverGroup(ReceiverGroup.PlayerHooks).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Generic);
		}

		private static PlaceableObject CreatePlayerDataSetter()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("PlayerData Setter");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<PlayerDataSetter>();
			return new CustomObject("PlayerData Hook", "player_data_setter", val, "[LEGACY]\n\nSets or checks a PlayerData boolean value.", null, preview: false, ResourceUtils.LoadSpriteResource("player_data_changer", (FilterMode)0, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.PlayerDataSetter).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PlayerDataSetter).WithBroadcasterGroup(BroadcasterGroup.Callable);
		}

		private static PlaceableObject CreateKeyListener()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Key Listener");
			val.AddComponent<KeyListener>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Key Listener", "key_listener", val, "[LEGACY]\n\nCan listen and broadcast events when keys are pressed and released.", null, preview: false, ResourceUtils.LoadSpriteResource("key_listener", (FilterMode)0, default(Vector4), 10f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.KeyListener).WithBroadcasterGroup(BroadcasterGroup.KeyListener);
		}

		private static PlaceableObject CreateRelay()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Relay");
			val.AddComponent<Relay>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Relay", "relay", val, "[LEGACY]\n\nBroadcasts the OnCall event when the Call trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("relay", (FilterMode)0, default(Vector4), 10f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Relay).WithBroadcasterGroup(BroadcasterGroup.Callable).WithReceiverGroup(ReceiverGroup.Relay);
		}

		private static PlaceableObject CreateCameraShaker()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0028: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Camera Shaker");
			val.AddComponent<CameraShaker>();
			val.transform.position = new Vector3(0f, 0f, 0.1f);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			return new CustomObject("Camera Shaker", "camera_shaker", val, "[LEGACY]\n\nShakes the camera when the 'Shake' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("camera_shaker", (FilterMode)1)).WithReceiverGroup(ReceiverGroup.CameraShaker).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CameraShaker);
		}

		private static PlaceableObject CreateAnimatorController()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Animator Controller");
			AnimPlayer.Init();
			PlayerAnimPlayer.Init();
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<PlayerAnimPlayer>();
			return new CustomObject("Animation Player", "anim_player", val, "[LEGACY]\n\nMakes Hornet perform a vanilla animation when the 'Play' trigger is called.", null, preview: false, ResourceUtils.LoadSpriteResource("anim_ctrl", (FilterMode)1, default(Vector4), 33f)).WithReceiverGroup(ReceiverGroup.AnimPlayer).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.AnimPlayer).WithBroadcasterGroup(BroadcasterGroup.Finishable);
		}

		private static PlaceableObject CreateTimeSlower()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			TimeSlower.Init();
			GameObject val = new GameObject("Time Slower");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<TimeSlower>();
			return new CustomObject("Time Slower", "time_manager", val, "[LEGACY]\n\nTemporarily slows the game's speed when the 'SlowTime' trigger is run.", null, preview: false, ResourceUtils.LoadSpriteResource("time_slower", (FilterMode)1, default(Vector4), 33f)).WithReceiverGroup(ReceiverGroup.TimeSlower).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.TimeSlower).WithBroadcasterGroup(BroadcasterGroup.Finishable);
		}
	}
	public static class MiscObjects
	{
		public static readonly Material LineMaterial = new Material(Shader.Find("Sprites/Default"));

		public static void Init()
		{
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			Categories.Misc.AddStart(CreateLine());
			Categories.Misc.AddStart(CreateTriangle());
			Categories.Misc.AddStart(CreateCircle());
			Categories.Misc.AddStart(CreateSquare());
			Categories.Effects.AddStart(CreateAudioObject());
			Categories.Effects.AddStart(CreateAsset<Mp4Object>("MP4", "custom_mp4", addRenderer: true, addVideo: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Mp4).WithReceiverGroup(ReceiverGroup.Playable).WithBroadcasterGroup(BroadcasterGroup.Finishable));
			Categories.Effects.AddStart(CreateAsset<WavObject>("WAV", "custom_wav", addRenderer: false, addVideo: false).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wav).WithReceiverGroup(ReceiverGroup.Wav).WithInputGroup(InputGroup.Wav));
			UIPngObject.Init();
			Categories.Effects.AddStart(CreateAsset<UIPngObject>("PNG (HUD)", "custom_png_ui", addRenderer: true, addVideo: false, "\n\nFrame Count options can be used to split a sprite sheet into an animation.\nBroadcasts 'OnFinish' when the animation ends.\n\nRenders on the HUD, can be used inside of a prefab and\nmade to appear in every room using the Spawn Prefab block.", preview: true).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PngUI).WithReceiverGroup(ReceiverGroup.Png).WithBroadcasterGroup(BroadcasterGroup.Finishable)
				.WithInputGroup(InputGroup.Png)
				.WithOutputGroup(OutputGroup.Png));
			Categories.Effects.AddStart(CreateAsset<PngObject>("PNG", "custom_png", addRenderer: true, addVideo: false, "\n\nFrame Count options can be used to split a sprite sheet into an animation.\nBroadcasts 'OnFinish' when the animation ends.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FullPng).WithReceiverGroup(ReceiverGroup.Png).WithBroadcasterGroup(BroadcasterGroup.Png)
				.WithInputGroup(InputGroup.Png)
				.WithOutputGroup(OutputGroup.Png));
			Categories.Misc.Add(CreateSilkSphere());
			Categories.Hazards.Add(CreateFrost());
			Categories.Platforming.Add(CreateWind());
			Categories.Platforming.Add(CreateBumper());
			Categories.Hazards.Add(CreateCustomHazard("White Thorns", "white_thorns", (Vector2[])(object)new Vector2[6]
			{
				new Vector2(-3.672f, -1.265f),
				new Vector2(-3.011f, 0.066f),
				new Vector2(-1.469f, 0.777f),
				new Vector2(0.474f, 1.282f),
				new Vector2(2.353f, 0.813f),
				new Vector2(3.754f, -0.674f)
			}));
			Categories.Hazards.Add(CreateJellyEgg());
			Categories.Hazards.Add(CreateWhiteSpikes());
		}

		private static PlaceableObject CreateJellyEgg()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_006c: 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)
			GameObject val = new GameObject("Jelly Egg Bomb");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<Rigidbody2D>().constraints = (RigidbodyConstraints2D)7;
			JellyEgg je = val.AddComponent<JellyEgg>();
			PreloadManager.RegisterPreload(new BasicPreload("localpoolprefabs_assets_shared.bundle", "Assets/Prefabs/Enemies/Generic Attacks/Gas Explosion Recycle M.prefab", delegate(GameObject o)
			{
				je.explosion = o;
			}, notSceneBundle: true));
			SpriteRenderer val2 = val.AddComponent<SpriteRenderer>();
			val2.sprite = ResourceUtils.LoadSpriteResource("jelly_egg_bomb", (FilterMode)1, default(Vector4), 64f);
			CircleCollider2D val3 = val.AddComponent<CircleCollider2D>();
			val3.radius = 0.6f;
			((Collider2D)val3).isTrigger = true;
			val.layer = LayerMask.NameToLayer("Terrain");
			Extensions.SetPositionZ(val.transform, 0.0065f);
			return new CustomObject("Jelly Egg Bomb", "jelly_egg", val, "Setting 'Regen Time' to 0 or more will make the\negg automatically regenerate after the configured number of seconds.").WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.JellyEgg);
		}

		private static PlaceableObject CreateWhiteSpikes()
		{
			//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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Moving Spikes");
			val.transform.localPosition = new Vector3(0f, 0f, 0.05f);
			GameObject val2 = val;
			val2.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val2);
			val2.AddComponent<SpriteRenderer>().sprite = ResourceUtils.LoadSpriteResource("Spikes.spikes_plate", (FilterMode)1, default(Vector4), 64f);
			GameObject val3 = new GameObject("Moving Part");
			val3.transform.parent = val2.transform;
			val3.transform.localPosition = new Vector3(0f, 0f, 0.05f);
			GameObject val4 = val3;
			WhiteSpikes.Init();
			val4.AddComponent<WhiteSpikes>();
			val4.AddComponent<SpriteRenderer>();
			GameObject val5 = new GameObject("Damager");
			val5.transform.parent = val4.transform;
			val5.layer = LayerMask.NameToLayer("Attack");
			GameObject val6 = val5;
			BoxCollider2D val7 = val6.AddComponent<BoxCollider2D>();
			((Collider2D)val7).offset = new Vector2(0f, 2.1f);
			val7.size = new Vector2(2f, 1.1f);
			TinkEffect ef1 = val6.AddComponent<TinkEffect>();
			val6.AddComponent<DamageHero>().hazardType = (HazardType)2;
			val6.AddComponent<DamageEnemies>().damageDealt = 20;
			GameObject val8 = new GameObject("Terrain");
			val8.transform.parent = val4.transform;
			val8.layer = LayerMask.NameToLayer("Terrain");
			GameObject val9 = val8;
			BoxCollider2D val10 = val9.AddComponent<BoxCollider2D>();
			((Collider2D)val10).offset = new Vector2(0f, -0.7f);
			val10.size = new Vector2(1.5f, 4.5f);
			TinkEffect ef2 = val9.AddComponent<TinkEffect>();
			PreloadManager.RegisterPreload(new BasicPreload("Greymoor_06", "Greymoor_windmill_cog (1)/GameObject/dustpen_trap_shine0000", delegate(GameObject o)
			{
				GameObject blockEffect = o.GetComponent<TinkEffect>().blockEffect;
				ef1.blockEffect = blockEffect;
				ef2.blockEffect = blockEffect;
			}));
			return new CustomObject("Moving Spikes", "wp_trap_spikes", val2, null, null, preview: false, ResourceUtils.LoadSpriteResource("Spikes.spikes_icon", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.WhiteSpikes).WithRotationGroup(RotationGroup.Four);
		}

		public static PlaceableObject CreateCustomHazard(string name, string id, Vector2[] points)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			Extensions.SetPositionZ(val.transform, 0.01f);
			EdgeCollider2D val2 = val.AddComponent<EdgeCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.points = points;
			val.AddComponent<CustomDamager>().damageAmount = 1;
			val.AddComponent<SpriteRenderer>().sprite = ResourceUtils.LoadSpriteResource(id, (FilterMode)1, default(Vector4), 64f);
			return new CustomObject(name, id, val).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Vines);
		}

		private static PlaceableObject CreateWind()
		{
			//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_001a: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Wind.Init();
			GameObject val = new GameObject("Wind")
			{
				layer = 6
			};
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			val2.size = new Vector2(10f, 10f);
			((Collider2D)val2).isTrigger = true;
			val.AddComponent<Wind>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Wind", "wind_zone", val, "Applies a force to players and some objects when inside the wind's hitbox.", null, preview: false, ResourceUtils.LoadSpriteResource("wind", (FilterMode)0, default(Vector4), 3.2f)).WithRotationGroup(RotationGroup.All).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Wind);
		}

		public static PlaceableObject CreateDreamBlock()
		{
			//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_0023: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			DreamBlock.Init();
			GameObject val = new GameObject("Dream Block")
			{
				layer = LayerMask.NameToLayer("Terrain")
			};
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			BoxCollider2D obj = val.AddComponent<BoxCollider2D>();
			obj.size *= 10f;
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.size *= 9.8f;
			val.AddComponent<DreamBlock>();
			val.AddComponent<SpriteRenderer>().sprite = ResourceUtils.LoadSpriteResource("Dream.dream_block", (FilterMode)0);
			Extensions.SetPositionZ(val.transform, 0.01f);
			return new CustomObject("Dream Block", "dream_block", val).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.DreamBlock);
		}

		private static PlaceableObject CreateSilkSphere()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Silk Sphere");
			SilkSphere.Init();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.transform.position = new Vector3(0f, 0f, 0.005f);
			val.AddComponent<SilkSphere>();
			val.AddComponent<HarpoonHook>();
			val.AddComponent<SpriteRenderer>().sprite = ResourceUtils.LoadSpriteResource("silk_sphere", (FilterMode)1, default(Vector4), 50f);
			CircleCollider2D val2 = val.AddComponent<CircleCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.radius = 2.2f;
			val.layer = LayerMask.NameToLayer("Interactive Object");
			return new CustomObject("Silk Sphere", "silk_sphere", val, "An infinite source of Silk.").WithRotationGroup(RotationGroup.All);
		}

		private static PlaceableObject CreateFrost()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Frost Marker");
			FrostMarker.Init();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<FrostMarker>();
			return new CustomObject("Frost", "frost_marker", val, "When enabled, the player will take frost damage over time.\n\nIf the player has the Faydown Cloak then frost will not affect them,\nunless a Frost Binding is active.\n\nThe player begins freezing after (100/frost speed) seconds,\nand hits are 1.75 seconds apart.", null, preview: false, ResourceUtils.LoadSpriteResource("cold_icon", (FilterMode)1, default(Vector4), 50f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Frost);
		}

		private static PlaceableObject CreateAsset<T>(string name, string id, bool addRenderer, bool addVideo, string extDesc = "", bool preview = false) where T : MonoBehaviour
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Custom Asset");
			if (addRenderer)
			{
				val.AddComponent<SpriteRenderer>().sprite = ArchitectPlugin.BlankSprite;
			}
			if (addVideo)
			{
				val.AddComponent<VideoPlayer>();
			}
			val.AddComponent<T>();
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			return new CustomObject("Custom " + name, id, val, sprite: ResourceUtils.LoadSpriteResource(id, (FilterMode)1, default(Vector4), 300f), description: "Places a custom " + name + " in the game.\n\nURL should be a direct download anyone can access\nin order to work with the level sharer." + extDesc, postSpawnAction: null, preview: preview).WithRotationGroup(RotationGroup.All);
		}

		private static PlaceableObject CreateAudioObject()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			AudioPlayer.Init();
			GameObject val = new GameObject("Audio Player");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<AudioPlayer>();
			return new CustomObject("Audio Player", "vanilla_audio_player", val, "Can play vanilla atmosphere or music cues.\nA list of all cues can be found in the guide.", null, preview: false, ResourceUtils.LoadSpriteResource("audio_player", (FilterMode)1, default(Vector4), 300f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.AudioPlayer).WithReceiverGroup(ReceiverGroup.AudioPlayer);
		}

		private static PlaceableObject CreateSquare()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateShape("square");
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.size = new Vector2(10f, 10f);
			return new CustomObject("Coloured Square", "coloured_square", val, "A square that can be coloured or given a hitbox for custom collision.\n\nRGBA colour values should be between 0 and 1.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Colours).WithRotationGroup(RotationGroup.All);
		}

		private static PlaceableObject CreateCircle()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateShape("circle");
			PolygonCollider2D val2 = val.AddComponent<PolygonCollider2D>();
			((Collider2D)val2).isTrigger = true;
			Vector2[] array = (Vector2[])(object)new Vector2[24];
			for (int i = 0; i < 24; i++)
			{
				float num = MathF.PI * 2f * (float)i / 24f;
				float num2 = Mathf.Cos(num) * 5f;
				float num3 = Mathf.Sin(num) * 5f;
				array[i] = new Vector2(num2, num3);
			}
			val2.pathCount = 1;
			val2.SetPath(0, array);
			return new CustomObject("Coloured Circle", "coloured_circle", val, "A circle that can be coloured or given a hitbox for custom collision.\n\nRGBA colour values should be between 0 and 1.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Colours).WithRotationGroup(RotationGroup.All);
		}

		private static PlaceableObject CreateLine()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Shape (Line)");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<LineObject>();
			LineRenderer val2 = val.AddComponent<LineRenderer>();
			((Renderer)val2).material = LineMaterial;
			EdgeCollider2D val3 = val.AddComponent<EdgeCollider2D>();
			((Collider2D)val3).isTrigger = true;
			return new CustomObject("Coloured Line Point", "coloured_line", val, "A point that can be combined with others to form lines that\ncan be coloured or given a hitbox for custom collision.\n\nFollows the config options of the first point of its ID that is placed.\n\nRGBA colour values should be between 0 and 1.", null, preview: false, ResourceUtils.LoadSpriteResource("line_point", (FilterMode)1, default(Vector4), 200f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Line).WithRotationGroup(RotationGroup.All);
		}

		private static PlaceableObject CreateTriangle()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateShape("triangle");
			EdgeCollider2D val2 = val.AddComponent<EdgeCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.points = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(-5f, -4.17f),
				new Vector2(0f, 4.45f),
				new Vector2(5f, -4.17f),
				new Vector2(-5f, -4.17f)
			};
			return new CustomObject("Coloured Triangle", "coloured_triangle", val, "A triangle that can be coloured or given a hitbox for custom collision.\n\nRGBA colour values should be between 0 and 1.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Colours).WithRotationGroup(RotationGroup.All);
		}

		private static GameObject CreateShape(string name)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0034: 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)
			Sprite sprite = ResourceUtils.LoadSpriteResource(name, (FilterMode)1);
			GameObject val = new GameObject("Shape (" + name + ")");
			Transform transform = val.transform;
			transform.localScale /= 3f;
			val.AddComponent<SpriteRenderer>().sprite = sprite;
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return val;
		}

		private static PlaceableObject CreateBumper()
		{
			//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_0023: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			Bumper.Init();
			GameObject val = new GameObject("Bumper")
			{
				layer = LayerMask.NameToLayer("Terrain")
			};
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.transform.position = new Vector3(0f, 0f, 0.005f);
			val.AddComponent<HarpoonHook>();
			val.AddComponent<Bumper>();
			val.AddComponent<SpriteRenderer>().sprite = Bumper.NormalIcon;
			CircleCollider2D val2 = val.AddComponent<CircleCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.radius = 0.7f;
			GameObject val3 = new GameObject("Damager");
			val3.transform.parent = val.transform;
			val3.layer = LayerMask.NameToLayer("Attack");
			GameObject val4 = val3;
			CircleCollider2D val5 = val4.AddComponent<CircleCollider2D>();
			((Collider2D)val5).isTrigger = true;
			val5.radius = 0.7f;
			val4.AddComponent<DamageHero>().hazardType = (HazardType)12;
			val4.AddComponent<DamageEnemies>().damageDealt = 20;
			return new CustomObject("Bumper", "celeste_bumper", val).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Bumpers).WithReceiverGroup(ReceiverGroup.Bumpers);
		}
	}
	public static class SplineObjects
	{
		public class SplinePoint : MonoBehaviour
		{
			public string id;

			public bool hasSetup;

			public Spline spline;

			private Transform _point;

			protected virtual void Setup()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: 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_006e: Expected O, but got Unknown
				spline = Splines[id];
				if (Object.op_Implicit((Object)(object)spline))
				{
					hasSetup = true;
					GameObject val = new GameObject("Point");
					val.transform.parent = ((Component)spline).transform;
					val.transform.position = ((Component)this).transform.position;
					GameObject val2 = val;
					SpawnedSplinePoint spawnedSplinePoint = val2.AddComponent<SpawnedSplinePoint>();
					spawnedSplinePoint.source = this;
					_point = val2.transform;
					spline.points.Add(_point);
					spline.splines.Add(this);
				}
			}

			protected virtual void Update()
			{
				if (!hasSetup && Splines.ContainsKey(id))
				{
					Setup();
				}
			}

			private void OnDisable()
			{
				if (Splines.TryGetValue(id, out var value) && Object.op_Implicit((Object)(object)value))
				{
					hasSetup = false;
					if (value.points.Count < 3)
					{
						value.Deactivate();
					}
					value.points.Remove(_point);
					value.splines.Remove(this);
					Object.Destroy((Object)(object)((Component)_point).gameObject);
				}
			}
		}

		public class SpawnedSplinePoint : MonoBehaviour
		{
			public SplinePoint source;

			private void Update()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)source) && Object.op_Implicit((Object)(object)source.spline))
				{
					Transform transform = ((Component)this).transform;
					Vector3 position = ((Component)source).transform.position;
					float? num = Extensions.GetPositionZ(((Component)source.spline).transform);
					transform.position = Extensions.Where(position, (float?)null, (float?)null, num);
				}
			}

			private void OnDestroy()
			{
				source.hasSetup = false;
			}
		}

		public class Spline : SplinePoint
		{
			public float r = 1f;

			public float g = 1f;

			public float b = 1f;

			public float a = 1f;

			public float speed;

			public HermiteSpline actualSpline;

			public List<SplinePoint> splines = new List<SplinePoint>();

			public List<Transform> points = new List<Transform>();

			private Transform _startPoint;

			private bool _setup;

			public Color LineColour
			{
				set
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_001a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					r = value.r;
					g = value.g;
					b = value.b;
					a = value.a;
				}
			}

			private void Start()
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				spline = this;
				GameObject val = new GameObject("Start Point");
				val.transform.parent = ((Component)this).transform;
				val.transform.localPosition = Vector3.zero;
				_startPoint = val.transform;
				points.Add(_startPoint);
			}

			protected override void Setup()
			{
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Expected O, but got Unknown
				if (points.Count >= 2)
				{
					points = points.OrderBy((Transform o) => (Object)(object)o != (Object)(object)_startPoint).ToList();
					hasSetup = true;
					actualSpline = ((Component)this).gameObject.AddComponent<HermiteSpline>();
					((SplineBase)actualSpline).preventCulling = true;
					((HermiteSplineBase)actualSpline).controlPoints = points;
					((SplineBase)actualSpline).InternalPoints = Array.Empty<Point>();
					((HermiteSplineBase)actualSpline).subdivisions = 25;
					Material val = MiscObjects.LineMaterial;
					Color val2 = default(Color);
					((Color)(ref val2))..ctor(r, g, b, a);
					if (val2 != Color.white)
					{
						val = new Material(val)
						{
							color = val2
						};
					}
					((Renderer)((Component)this).GetComponent<MeshRenderer>()).material = val;
				}
			}

			public void Deactivate()
			{
				hasSetup = false;
				Object.Destroy((Object)(object)actualSpline);
			}

			protected override void Update()
			{
				if (!_setup)
				{
					_setup = true;
					if (Splines.ContainsKey(id))
					{
						return;
					}
					Splines.Add(id, this);
				}
				base.Update();
			}

			private void OnDisable()
			{
				Deactivate();
				Splines.Remove(id);
			}
		}

		private static readonly Dictionary<string, Spline> Splines = new Dictionary<string, Spline>();

		public static void Init()
		{
			Categories.Utility.Add(CreateStartNode());
			Categories.Utility.Add(CreateNode());
		}

		private static PlaceableObject CreateStartNode()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Start Node");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<Spline>();
			return new CustomObject("Track Start Point", "start_node", val, "The start of a track.\nPlace Track Points with the same Track ID to link together and form a track.\n\nSetting a track point as the parent of an Object Anchor will cause it to\nfollow the track, starting at that point.\n\nSet the Colour A option to 0 to hide the track.", null, preview: true, ResourceUtils.LoadSpriteResource("track_start", (FilterMode)0, default(Vector4), 15f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.TrackStartPoint);
		}

		private static PlaceableObject CreateNode()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Node");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<SplinePoint>();
			return new CustomObject("Track Point", "node", val, "A point on a track.\nUse the Track Start Point to start a track.", null, preview: true, ResourceUtils.LoadSpriteResource("track_node", (FilterMode)0, default(Vector4), 15f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.TrackPoint).WithReceiverGroup(new List<EventReceiverType>());
		}
	}
	public static class UtilityObjects
	{
		public class EnemyDamager : MonoBehaviour
		{
			public HealthManager last;
		}

		private static readonly Dictionary<string, Func<GameObject, string, Disabler[]>> RemoverActions = new Dictionary<string, Func<GameObject, string, Disabler[]>>();

		public static readonly Sprite SquareDamager = ResourceUtils.LoadSpriteResource("enemy_damager", (FilterMode)0, default(Vector4), 64f);

		public static readonly Sprite CircleDamager = ResourceUtils.LoadSpriteResource("enemy_damager_circle", (FilterMode)0, default(Vector4), 64f);

		public static void Init()
		{
			Categories.Utility.Add(CreateItem());
			Categories.Utility.Add(CreateWalkArea());
			Categories.Utility.Add(CreateVoider());
			Categories.Utility.Add(CreatePlasmifier());
			Categories.Utility.Add(CreateShielder());
			Categories.Utility.Add(CreateObjectAnchor());
			Categories.Utility.Add(CreateObjectLayerer());
			Categories.Utility.Add(CreateObjectSpinner());
			Categories.Utility.Add(CreateObjectMover());
			Categories.Utility.Add(CreateObjectSpawner());
			Categories.Utility.Add(CreateObjectColourer());
			Categories.Utility.Add(CreateTriggerZone());
			Categories.Utility.Add(CreateEnemyDamager());
			Categories.Utility.Add(CreateInteraction());
			Categories.Utility.Add(CreateFakePerformance());
			Categories.Utility.Add(CreateEnemyHook());
			Categories.Utility.Add(CreateObjectHook());
			Categories.Utility.Add(CreateFsmHook());
			Categories.Utility.Add(CreateComponentToggler());
			Categories.Utility.Add(CreateCocoonSpawn());
			Categories.Utility.Add(CreateWalkTarget());
			Categories.Utility.Add(CreateDarkness());
			Categories.Utility.Add(CreateMemoryToggle());
			Categories.Utility.Add(CreateEnemyBarrier());
			Categories.Utility.Add(CreatePlayerBarrier());
			Categories.Utility.Add(CreateVignetteDisabler());
			Categories.Utility.Add(CreateObjectRemover("enemy_remover", "Disable Enemy", FindObjectsToDisable<HealthManager>, "Removes the nearest enemy.\n\nThis should be placed at the enemy's spawn point, not its\ncurrent position, or it will not work when exiting edit mode.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Disabler).WithReceiverGroup(ReceiverGroup.Generic));
			Categories.Utility.Add(CreateTeleportPoint());
			Categories.Utility.Add(CreateRespawnPoint());
			Categories.Utility.Add(CreateHazardRespawnPoint());
			Categories.Utility.Add(CreateObjectRemover("hrp_remover", "Disable Hazard Respawn Point", FindObjectsToDisable<HazardRespawnTrigger>, "Removes the nearest Hazard Respawn Point.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Disabler).WithReceiverGroup(ReceiverGroup.Generic));
			Categories.Utility.Add(CreateTransitionPoint());
			Categories.Utility.Add(CreateObjectRemover("door_remover", "Disable Transition", FindObjectsToDisable<TransitionPoint>, "Removes the nearest door to another room.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Generic).WithReceiverGroup(ReceiverGroup.Generic));
			Categories.Utility.Add(CreateBinoculars());
			Categories.Utility.Add(CreateCameraBorder());
			Categories.Utility.Add(CreateCameraRotator());
			Categories.Utility.Add(CreateSceneBorderRemover());
			Categories.Utility.Add(CreateSceneParticleManager());
			Categories.Utility.Add(CreateObjectRemover("collision_remover", "Disable Collider", delegate(GameObject disabler, string filter)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				List<Collider2D> list = new List<Collider2D>();
				List<Collider2D> list2 = new List<Collider2D>();
				Physics2D.OverlapArea(Vector2.op_Implicit(disabler.transform.position - Vector3.one), Vector2.op_Implicit(disabler.transform.position + Vector3.one), default(ContactFilter2D), list);
				Physics2D.OverlapPoint(Vector2.op_Implicit(disabler.transform.position), default(ContactFilter2D), list2);
				return (from i in list.Concat(list2)
					where ((Object)i).name.Contains(filter) && ((Component)i).gameObject.scene == disabler.scene
					select i into p
					select ((Component)p).gameObject.GetOrAddComponent<Disabler>()).ToArray();
			}, "Removes colliders touching this object.\nTrigger zones such as hazard respawn points do not count.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Remover).WithReceiverGroup(ReceiverGroup.Generic));
			Categories.Utility.Add(CreateObjectRemover("render_remover", "Disable Renderer", FindObjectsToDisable<Renderer>, "Removes the nearest renderer.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.DisableRenderer).WithReceiverGroup(ReceiverGroup.Generic));
			Categories.Legacy.Add(CreateObjectRemover("object_remover", "Disable Object", delegate(GameObject o, string _)
			{
				ObjectRemoverConfig component = o.GetComponent<ObjectRemoverConfig>();
				GameObject val = null;
				if (Object.op_Implicit((Object)(object)component))
				{
					try
					{
						val = ObjectUtils.FindGameObject(component.objectPath, component.index);
					}
					catch (ArgumentException)
					{
					}
				}
				return (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.GetComponent<Enabler>())) ? Array.Empty<Disabler>() : ((val == null) ? Array.Empty<Disabler>() : new Disabler[1] { val.GetOrAddComponent<Disabler>() });
			}, "Removes any vanilla objects from the game.\n\nThe path to an object can be found with tools such as Unity Explorer.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ObjectRemover).WithReceiverGroup(ReceiverGroup.Generic));
			Categories.Legacy.Add(CreateObjectEnabler());
			Categories.Utility.Add(CreateObjectRemover("room_remover", "Clear Room", delegate(GameObject o, string filter)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				RoomClearerConfig clearer = o.GetComponent<RoomClearerConfig>();
				if (!Object.op_Implicit((Object)(object)clearer))
				{
					return Array.Empty<Disabler>();
				}
				Scene scene = o.scene;
				IEnumerable<GameObject> source = from obj in ((Scene)(ref scene)).GetRootGameObjects()
					where !((Object)obj).name.StartsWith("[Architect]") && !((Object)obj).name.Contains("Hornet Cocoon Corpse") && !((Object)obj).name.StartsWith("_SceneManager") && !Object.op_Implicit((Object)(object)obj.GetComponent<CustomTransitionPoint>()) && !Object.op_Implicit((Object)(object)obj.GetComponent<WorldRumblePreventWhileActive>()) && !Object.op_Implicit((Object)(object)obj.GetComponentInChildren<SceneAdditiveLoadConditional>()) && ((Object)obj).name.Contains(filter)
					select obj;
				if (clearer.removeMusic && Utility.IsNullOrWhiteSpace(filter))
				{
					((Component)clearer).gameObject.AddComponent<MusicController>();
				}
				if (clearer.removeOther)
				{
					if (!clearer.removeBenches)
					{
						source = source.Where((GameObject obj) => !Object.op_Implicit((Object)(object)obj.GetComponent<RestBench>()));
					}
					if (!clearer.removeBlur)
					{
						source = source.Where((GameObject obj) => !Object.op_Implicit((Object)(object)obj.GetComponentInChildren<BlurPlane>()));
					}
					if (!clearer.removeTransitions)
					{
						source = source.Where((GameObject obj) => !Object.op_Implicit((Object)(object)obj.GetComponentInChildren<TransitionPoint>()));
					}
					if (!clearer.removeMusic)
					{
						source = source.Where((GameObject obj) => !Object.op_Implicit((Object)(object)obj.GetComponent<MusicRegion>()));
					}
					if (!clearer.removeTilemap)
					{
						source = source.Where((GameObject obj) => !((Object)obj).name.Contains("TileMap"));
					}
				}
				else
				{
					source = source.Where((GameObject obj) => (Object.op_Implicit((Object)(object)obj.GetComponent<RestBench>()) && clearer.removeBenches) || (Object.op_Implicit((Object)(object)obj.GetComponentInChildren<BlurPlane>()) && clearer.removeBlur) || (Object.op_Implicit((Object)(object)obj.GetComponentInChildren<TransitionPoint>()) && clearer.removeTransitions) || (Object.op_Implicit((Object)(object)obj.GetComponent<MusicRegion>()) && clearer.removeMusic) || (((Object)obj).name.Contains("TileMap") && clearer.removeTilemap));
				}
				return source.Select((GameObject obj) => obj.GetOrAddComponent<Disabler>()).ToArray();
			}, "Removes all existing objects in a room,\nsettings determine which objects are removed.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.RoomClearer).WithReceiverGroup(ReceiverGroup.Generic));
			Categories.Effects.Add(CreateRoar());
		}

		private static PlaceableObject CreateItem()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			CustomPickup.Init();
			GameObject val = new GameObject("Pickup Spawner");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<CustomPickup>();
			return new CustomObject("Item", "item_pickup", val, "A collectible item such as a Rosary String, Shard Bundle, Tool or Key.\nSome items may act strangely.\n\nDisabling 'Ignore Limit' will cause the item to disappear if the player normally cannot get more,\nsuch as if the item is a tool the player already has.\n\nA list of valid item IDs can be found in the Architect guide.", null, preview: false, ResourceUtils.LoadSpriteResource("item_pickup", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Item).WithReceiverGroup(ReceiverGroup.Item).WithBroadcasterGroup(BroadcasterGroup.Item);
		}

		private static PlaceableObject CreateWalkArea()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Walk Area");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.size = new Vector2(3.2f, 3.2f);
			val.AddComponent<WalkArea>();
			return new CustomObject("Walk Area", "walk_area", val, "Forces the player to walk (unless sprinting)", null, preview: false, ResourceUtils.LoadSpriteResource("walk_area", (FilterMode)0, default(Vector4), 64f));
		}

		private static PlaceableObject CreateRoar()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0038: 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)
			GameObject val = new GameObject("Roar Spawner");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<RoarEffect>();
			return new CustomObject("Roar Effect", "roar_effect", val, null, null, preview: false, ResourceUtils.LoadSpriteResource("roar", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Roar).WithReceiverGroup(ReceiverGroup.Roar);
		}

		private static PlaceableObject CreateFinalHit()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0038: 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)
			GameObject val = new GameObject("Final Hit");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<RoarEffect>();
			return new CustomObject("Final Hit Effect", "final_hit", val, null, null, preview: false, ResourceUtils.LoadSpriteResource("final_hit", (FilterMode)1, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.Roar);
		}

		private static PlaceableObject CreateBossExplosion()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0038: 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)
			GameObject val = new GameObject("Boss Explosion");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<RoarEffect>();
			return new CustomObject("Boss Explosion Effect", "boss_explosion", val, null, null, preview: false, ResourceUtils.LoadSpriteResource("boss_explosion", (FilterMode)1, default(Vector4), 64f)).WithReceiverGroup(ReceiverGroup.Roar);
		}

		private static PlaceableObject CreateVoider()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Voider");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			BlackThreader.Init();
			val.AddComponent<BlackThreader>();
			return new CustomObject("Black Threader", "black_threader", val, "Makes an enemy become black threaded, can either make the enemy start threaded\nor require the 'Activate' trigger to be run.\n\nEnemies will pick one void attack to use,\nthe chance of each attack is configurable.\n\nAlso works on certain non-enemies.", null, preview: false, ResourceUtils.LoadSpriteResource("black_threader", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.BlackThreader).WithBroadcasterGroup(BroadcasterGroup.BlackThreader).WithInputGroup(InputGroup.EnemyHook)
				.WithReceiverGroup(ReceiverGroup.BlackThreader);
		}

		private static PlaceableObject CreateEnemyHook()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Enemy Hook");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<EnemyHook>();
			return new CustomObject("Enemy Hook", "enemy_hook", val, "Allows connecting enemy events and triggers to vanilla enemies.\n\nThe path to an object can be found with tools such as Unity Explorer.", null, preview: false, ResourceUtils.LoadSpriteResource("enemy_hook", (FilterMode)0, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.EnemyHook).WithBroadcasterGroup(BroadcasterGroup.Enemies).WithInputGroup(InputGroup.EnemyHook)
				.WithOutputGroup(OutputGroup.EnemyHook)
				.WithReceiverGroup(ReceiverGroup.EnemyHook);
		}

		private static PlaceableObject CreateObjectHook()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Object Hook");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<ObjectHook>();
			return new CustomObject("Object Hook", "object_hook", val, "Allows using vanilla objects in the Script Editor.\n\nThe path to an object can be found with tools such as Unity Explorer.", null, preview: true, ResourceUtils.LoadSpriteResource("object_hook", (FilterMode)0)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ObjectHook).WithReceiverGroup(ReceiverGroup.ObjectHook).WithOutputGroup(OutputGroup.ObjectHook);
		}

		private static PlaceableObject CreateFsmHook()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("FSM Hook");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<FsmHook>();
			return new CustomObject("FSM Hook", "fsm_hook", val, "Allows detecting the current FSM State of an object.\nThe FSMSeer mod can be used to see FSM names and states.", null, preview: false, ResourceUtils.LoadSpriteResource("fsm_hook", (FilterMode)0, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FsmHook).WithReceiverGroup(ReceiverGroup.FsmHook).WithInputGroup(InputGroup.FsmHook)
				.WithBroadcasterGroup(BroadcasterGroup.FsmHook)
				.WithOutputGroup(OutputGroup.FsmHook);
		}

		private static PlaceableObject CreateComponentToggler()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Component Toggler");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<ComponentHook>();
			return new CustomObject("Component Hook", "component_toggle", val, "Allows enabling, disabling or removing components on an object.\nWorks on vanilla objects using their internal path.\n'Recursive' will get components of child objects too.", null, preview: false, ResourceUtils.LoadSpriteResource("component_hook", (FilterMode)0, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ComponentHook).WithReceiverGroup(ReceiverGroup.ComponentHook).WithInputGroup(InputGroup.ComponentHook);
		}

		private static PlaceableObject CreatePlasmifier()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Plasmifier");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<Plasmifier>();
			return new CustomObject("Plasmifier", "plasmifier", val, "Makes an enemy become plasmified, can either make the enemy start plasmified\nor require the 'Activate' trigger to be run.\n\nPlasmified enemies will heal every 0.75 seconds they are not damaged.", null, preview: false, ResourceUtils.LoadSpriteResource("plasmifier", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Plasmifier).WithReceiverGroup(ReceiverGroup.Plasmifier);
		}

		private static PlaceableObject CreateShielder()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Shielder");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			Shielder.Init();
			val.AddComponent<Shielder>();
			return new CustomObject("Resistance Changer", "shielder", val, "Toggles whether enemies take damage from certain sources.", null, preview: false, ResourceUtils.LoadSpriteResource("shielder", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Shielder).WithReceiverGroup(ReceiverGroup.Shielder);
		}

		private static PlaceableObject CreateWalkTarget()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Walk Target");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<WalkTarget>();
			return new CustomObject("Walk Target", "walk_target", val, "Forces the player to walk to this spot when the 'Start' trigger is called.\nAnimation and speed can be customised.\n\nCan be cancelled with the 'Cancel' trigger.\nCalls the 'OnFinish' event when the player arrives at the target.", null, preview: false, ResourceUtils.LoadSpriteResource("walk_target", (FilterMode)1, default(Vector4), 33f)).WithReceiverGroup(ReceiverGroup.WalkTarget).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.WalkTarget).WithBroadcasterGroup(BroadcasterGroup.Finishable);
		}

		private static PlaceableObject CreateDarkness()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Darkness");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<Darkness>();
			return new CustomObject("Darkness", "darkness", val, "Makes the room darker, reducing how far the player can see.\nPlacing 2 darkness objects at once will increase the effect.", null, preview: false, ResourceUtils.LoadSpriteResource("darkness", (FilterMode)1)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Darkness);
		}

		private static PlaceableObject CreateMemoryToggle()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			MapStateHook.Init();
			GameObject val = new GameObject("Memory Toggler");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<MapStateHook>();
			return new CustomObject("Memory Toggler", "memory_toggle", val, "Controls whether the current room is considered a memory.\n\nRosaries, Shell Shards and Items cannot spawn in memories\nand dying does not leave a cocoon.", null, preview: false, ResourceUtils.LoadSpriteResource("memory_toggle", (FilterMode)1, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.MapStateHook);
		}

		private static PlaceableObject CreateSceneParticleManager()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Scene Particle Disabler");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<SceneParticleController>();
			return new CustomObject("Scene Particle Disabler", "scene_particle_hook", val, "Disables scene specific particles that the Clear Room object cannot.", null, preview: false, ResourceUtils.LoadSpriteResource("scene_particle_remover", (FilterMode)1, default(Vector4), 64f));
		}

		private static PlaceableObject CreateTransitionPoint()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Transition Point");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			CustomTransitionPoint.Init();
			val.AddComponent<CustomTransitionPoint>();
			TransitionPoint val2 = val.AddComponent<TransitionPoint>();
			val2.entryPoint = "";
			val2.nonHazardGate = true;
			BoxCollider2D val3 = val.AddComponent<BoxCollider2D>();
			val3.size = new Vector2(3f, 3f);
			((Collider2D)val3).isTrigger = true;
			return new CustomObject("Transition Gate", "transition_gate", val, "Creates a custom doorway to another room. Requires a target scene and door id.\n\nDisable 'Collision Trigger' and use the 'Transition' trigger to transition when\nan event is received instead of when touching the door.", null, preview: true, ResourceUtils.LoadSpriteResource(Settings.PrideMode ? "door_trans" : "door", (FilterMode)1, default(Vector4), 33f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Transitions).WithReceiverGroup(ReceiverGroup.Transitions).WithBroadcasterGroup(BroadcasterGroup.Transitions);
		}

		private static PlaceableObject CreateCameraBorder()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_002e: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			CameraBorder.Init();
			GameObject val = new GameObject("Camera Border");
			val.AddComponent<CameraBorder>();
			val.transform.position = new Vector3(0f, 0f, 0.1f);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			return new CustomObject("Camera Border", "camera_border", val, "Stops the centre of the camera from passing a certain point.\n\nToggling this object with the Disable and Enable\ntriggers will toggle whether the border is active.\n\nChange the 'Active Mode' setting to control if the border is active everywhere,\nonly when not using Binoculars, or only when using Binoculars.", null, preview: false, ResourceUtils.LoadSpriteResource("camera_border", (FilterMode)1)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CameraBorder);
		}

		private static PlaceableObject CreateCameraRotator()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_002e: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			CameraRotator.Init();
			GameObject val = new GameObject("Camera Rotator");
			val.AddComponent<CameraRotator>();
			val.transform.position = new Vector3(0f, 0f, 0.1f);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			return new CustomObject("Camera Rotator", "camera_rotator", val, "Rotates the camera to the angle of this object.\n\nCan be used in combination with the Object Spinner\nto rotate the camera over time.", null, preview: false, ResourceUtils.LoadSpriteResource("camera_spinner", (FilterMode)1));
		}

		private static PlaceableObject CreateSceneBorderRemover()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003d: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Scene Border Remover");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			SceneBorderRemover.Init();
			val.AddComponent<SceneBorderRemover>();
			val.transform.position = new Vector3(0f, 0f, 0.1f);
			return new CustomObject("Scene Border Remover", "scene_border_remover", val, "Removes the borders of a room, making it possible\nto build out of bounds without needing to lock the camera.", null, preview: true, ResourceUtils.LoadSpriteResource("scene_border_remover", (FilterMode)1));
		}

		private static PlaceableObject CreateEnemyBarrier()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0027: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Enemy Barrier");
			int layer = LayerMask.NameToLayer("Hero Only");
			val.AddComponent<BoxCollider2D>().size = new Vector2(3.2f, 3.2f);
			val.layer = layer;
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Enemy Barrier", "enemy_blocker", val, "A barrier that enemies cannot pass through, but the player can.\n\nThis object is only a barrier, it does not function like terrain.", null, preview: false, ResourceUtils.LoadSpriteResource("enemy_blocker", (FilterMode)1, default(Vector4), 60f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Stretchable);
		}

		private static PlaceableObject CreatePlayerBarrier()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0027: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Player Barrier");
			int layer = LayerMask.NameToLayer("Hero Detector");
			val.AddComponent<BoxCollider2D>().size = new Vector2(3.2f, 3.2f);
			val.layer = layer;
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Player Barrier", "player_blocker", val, "A barrier that the player cannot pass through, but enemies can.\n\nThis object is similar to terrain but does not block enemies.", null, preview: false, ResourceUtils.LoadSpriteResource("player_blocker", (FilterMode)1, default(Vector4), 60f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.PlayerBarrier);
		}

		private static PlaceableObject CreateVignetteDisabler()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			VignetteDisabler.Init();
			GameObject val = new GameObject("Vignette Disabler");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<VignetteDisabler>();
			return new CustomObject("Disable Vignette", "vignette_disabler", val, "Disables the Vignette effect.", null, preview: false, ResourceUtils.LoadSpriteResource("vignette_disabler", (FilterMode)0));
		}

		private static PlaceableObject CreateFakePerformance()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			FakePerformanceRegion.Init();
			GameObject val = new GameObject("Fake Needolin");
			val.AddComponent<FakePerformanceRegion>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Fake Needolin Performance", "fake_performance", val, "Acts like the Needolin is playing at this object's position when it is active.", null, preview: false, ResourceUtils.LoadSpriteResource("fake_performance", (FilterMode)0, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.FakePerformance);
		}

		private static PlaceableObject CreateCocoonSpawn()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("[Architect] Cocoon Spawn Point");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<HeroCorpseMarker>().guidComponent = (GuidComponent)(object)val.AddComponent<CustomGuidComponent>();
			return new CustomObject("Cocoon Spawn Point", "cocoon_spawn", val, "Cocoon spawns at the nearest spawn point.", null, preview: false, ResourceUtils.LoadSpriteResource("cocoon_spawn", (FilterMode)0, default(Vector4), 64f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.CocoonSpawnPoint);
		}

		private static PlaceableObject CreateObjectSpawner()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Object Duplicator");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<ObjectDuplicator>();
			return new CustomObject("Object Spawner", "object_duplicator", val, "Spawns a copy of a placed object.\nCopies have the same settings as the original object.\n\nFind the ID of the object to copy using the Cursor tool.\n\nThe original object should have 'Start Enabled' set to false.", null, preview: false, ResourceUtils.LoadSpriteResource("object_duplicator", (FilterMode)0)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Duplicator).WithReceiverGroup(ReceiverGroup.Duplicator);
		}

		private static PlaceableObject CreateObjectColourer()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			ObjectColourer.Init();
			GameObject val = new GameObject("Object Colourer");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<ObjectColourer>();
			return new CustomObject("Object Colourer", "object_colourer", val, "Changes the colour of an object.\nThis works with most objects, but not all of them.\n\nFind the ID of the object to copy using the Cursor tool.", null, preview: false, ResourceUtils.LoadSpriteResource("object_colourer", (FilterMode)0)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Colourer).WithInputGroup(InputGroup.Colourer).WithReceiverGroup(ReceiverGroup.Colourer);
		}

		private static PlaceableObject CreateObjectAnchor()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Object Anchor");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			ObjectAnchor.Init();
			val.AddComponent<ObjectAnchor>();
			return new CustomObject("Object Anchor", "object_anchor", val, "Used to move objects.\n\nSet Move Speed above 0 for the anchor to move linearly.\n\nSet the Parent ID to make the anchor follow the parent,\nor set it to a Track Point to make the anchor move along the track.\n\nFind the ID of the object and parent by clicking them with the Cursor tool\nor holding the 'I' key and clicking the object.", null, preview: true, ResourceUtils.LoadSpriteResource("object_anchor", (FilterMode)0)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ObjectAnchor).WithReceiverGroup(ReceiverGroup.ObjectAnchor).WithOutputGroup(OutputGroup.ObjectAnchor)
				.WithBroadcasterGroup(BroadcasterGroup.ObjectAnchor);
		}

		private static PlaceableObject CreateObjectLayerer()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Object Layer Changer");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<Layerer>();
			return new CustomObject("Object Layer Changer", "object_layerer", val, "Changes the layer of the target object, affecting things like collision.", null, preview: true, ResourceUtils.LoadSpriteResource("object_layerer", (FilterMode)0)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ObjectLayerer).WithReceiverGroup(ReceiverGroup.ObjectLayerer);
		}

		private static PlaceableObject CreateObjectMover()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Object Mover");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<ObjectMover>();
			return new CustomObject("Object Mover", "object_mover", val, "Teleports an object to another position relative to itself, the mover, the player\nor another object. Position Source ID (an Object ID) overrides Position Source.\n\nThis should be used for individual teleports.\nTo move an object as if on a track, use the Object Anchor.\nTo rotate an object over time, use the Object Spinner.", null, preview: false, ResourceUtils.LoadSpriteResource("object_mover", (FilterMode)0)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ObjectMover).WithReceiverGroup(ReceiverGroup.ObjectMover).WithInputGroup(InputGroup.ObjectMover);
		}

		private static PlaceableObject CreateObjectSpinner()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Object Spinner");
			val.AddComponent<ObjectSpinner>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Object Spinner", "object_spinner", val, "Used to rotate objects at configurable speeds.\nMay cause unusual behaviour with objects that are not intended to be rotated.\n\nFind the ID of the object to rotate by clicking it with the Cursor tool.\n\nHold the 'P' keybind to preview the movement of placed objects.", null, preview: true, ResourceUtils.LoadSpriteResource("object_spinner", (FilterMode)0)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ObjectSpinner).WithReceiverGroup(ReceiverGroup.ObjectSpinner);
		}

		private static PlaceableObject CreateTriggerZone()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Trigger Zone");
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.size = new Vector2(3.2f, 3.2f);
			PolygonCollider2D val3 = val.AddComponent<PolygonCollider2D>();
			((Collider2D)val3).isTrigger = true;
			Vector2[] array = (Vector2[])(object)new Vector2[24];
			for (int i = 0; i < 24; i++)
			{
				float num = MathF.PI * 2f * (float)i / 24f;
				float num2 = Mathf.Cos(num) * 1.6f;
				float num3 = Mathf.Sin(num) * 1.6f;
				array[i] = new Vector2(num2, num3);
			}
			val3.pathCount = 1;
			val3.SetPath(0, array);
			((Behaviour)val3).enabled = false;
			val.AddComponent<TriggerZone>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Trigger Zone", "trigger_zone", val, "Can broadcast events when entered or exited.\n\n'Activator' mode detects Shakra Rings, Kratt and Beastlings,\na trigger layer can be set to only detect specific objects.", null, preview: false, TriggerZone.SquareZone).WithBroadcasterGroup(BroadcasterGroup.TriggerZone).WithReceiverGroup(ReceiverGroup.TriggerZone).WithOutputGroup(OutputGroup.TriggerZone)
				.WithConfigGroup(Architect.Objects.Groups.ConfigGroup.TriggerZones);
		}

		private static PlaceableObject CreateEnemyDamager()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Enemy Damager")
			{
				layer = LayerMask.NameToLayer("Attack")
			};
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.size = new Vector2(3.2f, 3.2f);
			val.AddComponent<NonBouncer>();
			PolygonCollider2D val3 = val.AddComponent<PolygonCollider2D>();
			((Collider2D)val3).isTrigger = true;
			Vector2[] array = (Vector2[])(object)new Vector2[24];
			for (int i = 0; i < 24; i++)
			{
				float num = MathF.PI * 2f * (float)i / 24f;
				float num2 = Mathf.Cos(num) * 1.6f;
				float num3 = Mathf.Sin(num) * 1.6f;
				array[i] = new Vector2(num2, num3);
			}
			val3.pathCount = 1;
			val3.SetPath(0, array);
			((Behaviour)val3).enabled = false;
			DamageEnemies val4 = val.AddComponent<DamageEnemies>();
			val4.damageDealt = 5;
			val.AddComponent<EnemyDamager>();
			val.AddComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)1;
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Enemy Damager", "enemy_damager", val, "Damages enemies inside the zone with configurable damage and damage types.", delegate(GameObject o)
			{
				o.GetComponent<DamageEnemies>().DamagedEnemyHealthManager += delegate(HealthManager manager)
				{
					o.GetComponent<EnemyDamager>().last = manager;
					o.BroadcastEvent("OnDamage");
				};
			}, preview: false, SquareDamager).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.EnemyDamager).WithReceiverGroup(ReceiverGroup.EnemyDamager).WithBroadcasterGroup(BroadcasterGroup.EnemyDamager)
				.WithOutputGroup(OutputGroup.EnemyDamager)
				.WithInputGroup(InputGroup.EnemyDamager);
		}

		private static PlaceableObject CreateInteraction()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			CustomInteraction.Init();
			GameObject val = new GameObject("Interaction");
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.size = new Vector2(3.2f, 3.2f);
			val.AddComponent<CustomInteraction>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Interaction", "interaction", val, "Hovering text appears when the player stands in the interaction's range,\nbroadcasts an event when interacted with.", null, preview: false, ResourceUtils.LoadSpriteResource("interaction", (FilterMode)0, default(Vector4), 10f)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Interaction).WithBroadcasterGroup(BroadcasterGroup.Interaction);
		}

		private static PlaceableObject CreateObjectRemover(string id, string name, [CanBeNull] Func<GameObject, string, Disabler[]> action, string desc)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Object Remover (" + id + ")");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			RemoverActions[id] = action;
			val.AddComponent<ObjectRemover>().triggerName = id;
			Sprite sprite = ResourceUtils.LoadSpriteResource(id, (FilterMode)0);
			val.transform.position = new Vector3(0f, 0f, -2f);
			return new CustomObject(name, id, val, desc, null, preview: true, sprite).WithReceiverGroup(ReceiverGroup.Generic);
		}

		private static PlaceableObject CreateObjectEnabler()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Object Enabler");
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			val.AddComponent<ObjectEnabler>();
			Sprite sprite = ResourceUtils.LoadSpriteResource("object_enabler", (FilterMode)0);
			val.transform.position = new Vector3(0f, 0f, -2f);
			return new CustomObject("Enable Object", "object_enabler", val, "Enables a disabled object.\n\nThe path to an object can be found with tools such as Unity Explorer.", null, preview: true, sprite).WithReceiverGroup(ReceiverGroup.Generic).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.ObjectEnabler);
		}

		public static Disabler[] GetObjects(ObjectRemover editor)
		{
			return RemoverActions[editor.triggerName](((Component)editor).gameObject, editor.filter);
		}

		private static Disabler[] FindObjectsToDisable<T>(GameObject disabler, string filter) where T : Component
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			Scene scene = disabler.scene;
			IEnumerable<GameObject> enumerable = from obj in (from obj in ((Scene)(ref scene)).GetRootGameObjects()
					where !((Object)obj).name.StartsWith("[Architect] ") && ((Object)obj).name.Contains(filter) && !Object.op_Implicit((Object)(object)obj.GetComponent<CustomTransitionPoint>())
					select obj).SelectMany((GameObject root) => root.GetComponentsInChildren<T>(true))
				select ((Component)obj).gameObject;
			ObjectRemover or = disabler.GetComponent<ObjectRemover>();
			if (Object.op_Implicit((Object)(object)or))
			{
				if (or.all)
				{
					return enumerable.Select((GameObject o) => o.GetOrAddComponent<Disabler>()).ToArray();
				}
				if (or.allInRange)
				{
					return (from o in enumerable.Where(delegate(GameObject o)
						{
							//IL_0006: 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_001b: Unknown result type (might be due to invalid IL or missing references)
							//IL_003f: Unknown result type (might be due to invalid IL or missing references)
							//IL_0044: Unknown result type (might be due to invalid IL or missing references)
							Vector3 val3 = o.transform.position - disabler.transform.position;
							float? num2 = 0f;
							Vector3 val4 = Extensions.Where(val3, (float?)null, (float?)null, num2);
							return ((Vector3)(ref val4)).sqrMagnitude < or.range * or.range;
						})
						select o.GetOrAddComponent<Disabler>()).ToArray();
				}
			}
			float num = float.MaxValue;
			GameObject val = null;
			foreach (GameObject item in enumerable)
			{
				Vector3 val2 = item.transform.position - disabler.transform.position;
				val2.z = 0f;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					val = item;
				}
			}
			return (val == null || !(num <= or.range * or.range)) ? Array.Empty<Disabler>() : new Disabler[1] { val.gameObject.GetOrAddComponent<Disabler>() };
		}

		private static PlaceableObject CreateHazardRespawnPoint()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Hazard Respawn Point");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<HazardRespawnTrigger>().respawnMarker = (HazardRespawnMarker)(object)val.AddComponent<CustomHazardRespawnMarker>();
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			val2.size = Vector2.one;
			((Collider2D)val2).isTrigger = true;
			return new CustomObject("Hazard Respawn Point", "hazard_respawn_point", val, "A point that the player can respawn at after taking hazard damage.", null, preview: true, ResourceUtils.LoadSpriteResource("hazard_respawn_point", (FilterMode)1)).WithConfigGroup(Architect.Objects.Groups.ConfigGroup.HazardRespawn).WithReceiverGroup(ReceiverGroup.HazardRespawn);
		}

		private static PlaceableObject CreateRespawnPoint()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003c: 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)
			GameObject val = new GameObject("Respawn Point");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<RespawnMarker>();
			return new CustomObject("Respawn Point", "respawn_point", val, "A point that the player can respawn at after dying.\n\nTo set the player's spawn use the 'SetSpawn' trigger.", null, preview: true, ResourceUtils.LoadSpriteResource("respawn_point", (FilterMode)1, default(Vector4), 50f)).WithFlipAction(delegate(GameObject o, bool f)
			{
				if (f)
				{
					o.GetComponent<RespawnMarker>().respawnFacingRight = true;
				}
			}).WithReceiverGroup(ReceiverGroup.Respawn);
		}

		private static PlaceableObject CreateTeleportPoint()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Teleport Point");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Teleport Point", "telepoint", val, "Teleports the player to this point when the 'Teleport' trigger is called.", null, preview: false, ResourceUtils.LoadSpriteResource("telepoint", (FilterMode)1)).WithReceiverGroup(ReceiverGroup.TeleportPoint);
		}

		private static PlaceableObject CreateBinoculars()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Binoculars");
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.size = new Vector2(1.25f, 1.06f);
			val.AddComponent<SpriteRenderer>().sprite = ResourceUtils.LoadSpriteResource("binoculars", (FilterMode)1);
			Binoculars.Init();
			int layer = LayerMask.NameToLayer("Soft Terrain");
			val.layer = layer;
			val.AddComponent<Binoculars>();
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)val);
			return new CustomObject("Binoculars", "freecam", val, "Enables a Freecam mode when hit by the player,\nor when receiving the StartUsing trigger. Use the scroll wheel to zoom in/out.\n\nUseful for giving players a preview of a map.\n\nPress jump to leave Freecam mode.").WithConfigGroup(Architect.Objects.Groups.ConfigGroup.Binoculars).WithReceiverGroup(ReceiverGroup.Binoculars).WithBroadcasterGroup(BroadcasterGroup.Binoculars);
		}
	}
}
namespace Architect.Config
{
	public static class ConfigurationManager
	{
		public enum PreviewContext
		{
			Cursor,
			Placement
		}

		public static readonly Dictionary<string, Architect.Config.Types.ConfigType> ConfigTypes = new Dictionary<string, Architect.Config.Types.ConfigType>();

		public static Architect.Config.Types.ConfigType RegisterConfigType(Architect.Config.Types.ConfigType type)
		{
			ConfigTypes[type.Id] = type;
			return type;
		}

		public static Architect.Config.Types.ConfigValue DeserializeConfigValue(string configType, string serializedValue)
		{
			Architect.Config.Types.ConfigType value;
			return ConfigTypes.TryGetValue(configType, out value) ? value.Deserialize(serializedValue) : null;
		}
	}
}
namespace Architect.Config.Types
{
	public class BoolConfigType : ConfigType<BoolConfigValue>
	{
		private bool? _defaultValue;

		public BoolConfigType(string name, string id, Action<GameObject, BoolConfigValue> action, [CanBeNull] Action<GameObject, BoolConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public BoolConfigType WithDefaultValue(bool value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new BoolConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new BoolConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new BoolConfigValue(this, Convert.ToBoolean(data, CultureInfo.InvariantCulture));
		}
	}
	public class BoolConfigValue : ConfigValue<BoolConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private bool <value>P;

		public BoolConfigValue(BoolConfigType type, bool value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public bool GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class BoolConfigElement : ConfigElement
	{
		private readonly Button _input;

		private bool _active = true;

		public BoolConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			BoolConfigElement boolConfigElement = this;
			UIUtils.Label txt;
			(_input, txt) = UIUtils.MakeTextButton("Config Input", "Default", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(120f, 25f));
			if (currentVal != null)
			{
				((Text)txt.textComponent).text = currentVal;
				_active = Convert.ToBoolean(currentVal, CultureInfo.InvariantCulture);
			}
			((UnityEvent)_input.onClick).AddListener((UnityAction)delegate
			{
				boolConfigElement._active = !boolConfigElement._active;
				((Text)txt.textComponent).text = boolConfigElement._active.ToString(CultureInfo.InvariantCulture);
				((Selectable)apply).interactable = true;
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _active.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class ChoiceConfigType : ConfigType<ChoiceConfigValue>
	{
		private int? _defaultValue;

		private string[] _options = Array.Empty<string>();

		public ChoiceConfigType(string name, string id, Action<GameObject, ChoiceConfigValue> action, [CanBeNull] Action<GameObject, ChoiceConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public ChoiceConfigType WithOptions(params string[] options)
		{
			_options = options;
			return this;
		}

		public ChoiceConfigType WithDefaultValue(int value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new ChoiceConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new ChoiceConfigElement(parent, apply, pos, currentVal, _options);
		}

		public override ConfigValue Deserialize(string data)
		{
			if (1 == 0)
			{
			}
			int num = ((!(data == "True")) ? ((data == "False") ? 1 : Convert.ToInt32(data, CultureInfo.InvariantCulture)) : 0);
			if (1 == 0)
			{
			}
			int value = num;
			return new ChoiceConfigValue(this, value);
		}

		public string GetOption(int index)
		{
			return _options[(index < _options.Length) ? index : 0];
		}
	}
	public class ChoiceConfigValue : ConfigValue<ChoiceConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private int <value>P;

		private readonly ChoiceConfigType _type;

		public ChoiceConfigValue(ChoiceConfigType type, int value)
		{
			<value>P = value;
			_type = type;
			base..ctor(type);
		}

		public int GetValue()
		{
			return <value>P;
		}

		public string GetStringValue()
		{
			return _type.GetOption(<value>P);
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class ChoiceConfigElement : ConfigElement
	{
		public class ChoiceButton : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			public ChoiceConfigElement Cce;

			public void OnPointerClick(PointerEventData eventData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected I4, but got Unknown
				InputButton button = eventData.button;
				InputButton val = button;
				switch ((int)val)
				{
				default:
					return;
				case 0:
					Cce._active++;
					break;
				case 1:
					if (Cce._active != -1)
					{
						Cce._active--;
					}
					break;
				case 2:
					return;
				}
				if (Cce._active < 0)
				{
					Cce._active += Cce._options.Length;
				}
				Cce._active %= Cce._options.Length;
				((Text)Cce._txt.textComponent).text = Cce._options[Cce._active];
				((Selectable)Cce._apply).interactable = true;
			}
		}

		private readonly Button _input;

		private readonly string[] _options;

		private readonly Button _apply;

		private readonly UIUtils.Label _txt;

		private int _active = -1;

		public ChoiceConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal, string[] options)
		{
			//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_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)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			(Button, UIUtils.Label) tuple = UIUtils.MakeTextButton("Config Input", "Default", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, hasOutline: true, new Vector2(120f, 25f));
			_input = tuple.Item1;
			_txt = tuple.Item2;
			_options = options;
			_apply = apply;
			ChoiceButton choiceButton = ((Component)_input).gameObject.AddComponent<ChoiceButton>();
			choiceButton.Cce = this;
			if (currentVal != null)
			{
				_active = Convert.ToInt32(currentVal, CultureInfo.InvariantCulture);
				((Text)_txt.textComponent).text = options[_active];
			}
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _active.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class ColourConfigType : ConfigType<ColourConfigValue>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private bool <alpha>P;

		private Color? _defaultValue;

		public ColourConfigType(string name, string id, Action<GameObject, ColourConfigValue> action, bool alpha, [CanBeNull] Action<GameObject, ColourConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
		{
			<alpha>P = alpha;
			base..ctor(name, id, action, previewAction);
		}

		public ColourConfigType WithDefaultValue(Color value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return _defaultValue.HasValue ? new ColourConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new ColourConfigElement(parent, apply, pos, currentVal, <alpha>P);
		}

		public override ConfigValue Deserialize(string data)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Color value;
			try
			{
				value = JsonConvert.DeserializeObject<Color>(data);
			}
			catch
			{
				value = Color.white;
			}
			return new ColourConfigValue(this, value);
		}
	}
	public class ColourConfigValue : ConfigValue<ColourConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Color <value>P;

		public ColourConfigValue(ColourConfigType type, Color value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			<value>P = value;
			base..ctor(type);
		}

		public Color GetValue()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return <value>P;
		}

		public override string SerializeValue()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return JsonConvert.SerializeObject((object)<value>P);
		}
	}
	public class ColourConfigElement : ConfigElement
	{
		private readonly RectTransform _parent;

		private readonly InputField _inputR;

		private readonly InputField _inputG;

		private readonly InputField _inputB;

		private readonly InputField _inputA;

		public ColourConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal, bool alpha)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0062: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Config Input");
			val.transform.parent = parent.transform;
			val.transform.localScale = Vector3.one;
			GameObject val2 = val;
			_parent = val2.RemoveOffset();
			_parent.anchoredPosition = Vector2.op_Implicit(pos);
			float num = (alpha ? 17.5f : 0f);
			_inputR = UIUtils.MakeTextbox("R", val2, Vector2.op_Implicit(new Vector3(-35f - num, 0f)), Vector2.zero, Vector2.zero, 80f, 25f).Item1;
			_inputG = UIUtils.MakeTextbox("G", val2, Vector2.op_Implicit(new Vector3(0f - num, 0f)), Vector2.zero, Vector2.zero, 80f, 25f).Item1;
			_inputB = UIUtils.MakeTextbox("B", val2, Vector2.op_Implicit(new Vector3(35f - num, 0f)), Vector2.zero, Vector2.zero, 80f, 25f).Item1;
			if (alpha)
			{
				_inputA = UIUtils.MakeTextbox("A", val2, Vector2.op_Implicit(new Vector3(52.5f, 0f)), Vector2.zero, Vector2.zero, 80f, 25f).Item1;
			}
			if (currentVal != null)
			{
				Color val3 = JsonConvert.DeserializeObject<Color>(currentVal);
				_inputR.text = val3.r.ToString(CultureInfo.InvariantCulture);
				_inputG.text = val3.g.ToString(CultureInfo.InvariantCulture);
				_inputB.text = val3.b.ToString(CultureInfo.InvariantCulture);
				if (alpha)
				{
					_inputA.text = val3.a.ToString(CultureInfo.InvariantCulture);
				}
			}
			string lastR = _inputR.text;
			string lastG = _inputG.text;
			string lastB = _inputB.text;
			InputField inputR = _inputR;
			InputField inputG = _inputG;
			InputField inputB = _inputB;
			CharacterValidation val4 = (CharacterValidation)2;
			inputB.characterValidation = (CharacterValidation)2;
			inputR.characterValidation = (inputG.characterValidation = val4);
			if (alpha)
			{
				_inputA.characterValidation = (CharacterValidation)2;
			}
			((UnityEvent<string>)(object)_inputR.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastR == s))
				{
					lastR = s;
					((Selectable)apply).interactable = true;
				}
			});
			((UnityEvent<string>)(object)_inputG.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastG == s))
				{
					lastG = s;
					((Selectable)apply).interactable = true;
				}
			});
			((UnityEvent<string>)(object)_inputB.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastB == s))
				{
					lastB = s;
					((Selectable)apply).interactable = true;
				}
			});
			if (!alpha)
			{
				return;
			}
			string lastA = _inputA.text;
			((UnityEvent<string>)(object)_inputA.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastA == s))
				{
					lastA = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			return _parent;
		}

		public override string GetValue()
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (!float.TryParse(_inputR.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				result = 1f;
			}
			if (!float.TryParse(_inputG.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				result2 = 1f;
			}
			if (!float.TryParse(_inputB.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				result3 = 1f;
			}
			float result4 = 1f;
			if (Object.op_Implicit((Object)(object)_inputA))
			{
				float.TryParse(_inputA.text, NumberStyles.Float, CultureInfo.InvariantCulture, out result4);
			}
			return JsonConvert.SerializeObject((object)new Color(result, result2, result3, result4));
		}
	}
	public abstract class ConfigType
	{
		public readonly string Name;

		public readonly string Id;

		public int Priority;

		protected ConfigType(string name, string id)
		{
			Name = name;
			Id = id;
			base..ctor();
		}

		public abstract ConfigValue Deserialize(string data);

		[CanBeNull]
		public abstract ConfigValue GetDefaultValue();

		public abstract ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal);

		internal abstract void RunAction(GameObject obj, ConfigValue value);

		internal abstract void RunActionPreview(GameObject obj, ConfigValue value, ConfigurationManager.PreviewContext context);
	}
	public abstract class ConfigType<TValue> : ConfigType where TValue : ConfigValue
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Action<GameObject, TValue> <action>P;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Action<GameObject, TValue, ConfigurationManager.PreviewContext> <previewAction>P;

		protected ConfigType(string name, string id, Action<GameObject, TValue> action, [CanBeNull] Action<GameObject, TValue, ConfigurationManager.PreviewContext> previewAction)
		{
			<action>P = action;
			<previewAction>P = previewAction;
			base..ctor(name, id);
		}

		public ConfigType<TValue> WithPriority(int priority)
		{
			Priority = priority;
			return this;
		}

		internal override void RunAction(GameObject obj, ConfigValue value)
		{
			<action>P(obj, value as TValue);
		}

		internal override void RunActionPreview(GameObject obj, ConfigValue value, ConfigurationManager.PreviewContext context)
		{
			<previewAction>P?.Invoke(obj, value as TValue, context);
		}
	}
	public abstract class ConfigValue
	{
		public abstract string SerializeValue();

		public abstract string GetTypeId();

		public abstract string GetName();

		public abstract int GetPriority();

		public abstract void Setup(GameObject obj, string extraId);

		public abstract void SetupPreview(GameObject obj, ConfigurationManager.PreviewContext context);
	}
	public abstract class ConfigValue<TType> : ConfigValue where TType : ConfigType
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private TType <type>P;

		protected ConfigValue(TType type)
		{
			<type>P = type;
			base..ctor();
		}

		public override string GetTypeId()
		{
			return <type>P.Id;
		}

		public override string GetName()
		{
			return <type>P.Name;
		}

		public override void Setup(GameObject obj, string extraId)
		{
			<type>P.RunAction(obj, this);
		}

		public override void SetupPreview(GameObject obj, ConfigurationManager.PreviewContext context)
		{
			<type>P.RunActionPreview(obj, this, context);
		}

		public override int GetPriority()
		{
			return <type>P.Priority;
		}
	}
	public abstract class ConfigElement
	{
		public abstract RectTransform GetElement();

		public abstract string GetValue();
	}
	public class DoubleIntConfigType : ConfigType<DoubleIntConfigValue>
	{
		private (int, int)? _defaultValue;

		public DoubleIntConfigType(string name, string id, Action<GameObject, DoubleIntConfigValue> action, [CanBeNull] Action<GameObject, DoubleIntConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public DoubleIntConfigType WithDefaultValue((int, int) value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new DoubleIntConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new DoubleIntConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			(int, int) value;
			try
			{
				value = JsonConvert.DeserializeObject<(int, int)>(data);
			}
			catch
			{
				value = (0, 0);
			}
			return new DoubleIntConfigValue(this, value);
		}
	}
	public class DoubleIntConfigValue : ConfigValue<DoubleIntConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private (int, int) <value>P;

		public DoubleIntConfigValue(DoubleIntConfigType type, (int, int) value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public (int, int) GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return JsonConvert.SerializeObject((object)<value>P);
		}
	}
	public class DoubleIntConfigElement : ConfigElement
	{
		private readonly RectTransform _parent;

		private readonly InputField _inputX;

		private readonly InputField _inputY;

		public DoubleIntConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0062: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Config Input");
			val.transform.parent = parent.transform;
			val.transform.localScale = Vector3.one;
			GameObject val2 = val;
			_parent = val2.RemoveOffset();
			_parent.anchoredPosition = Vector2.op_Implicit(pos);
			(_inputX, _) = UIUtils.MakeTextbox("X", val2, Vector2.op_Implicit(new Vector3(-17.5f, 0f)), Vector2.zero, Vector2.zero, 80f, 25f);
			(_inputY, _) = UIUtils.MakeTextbox("Y", val2, new Vector2(17.5f, 0f), Vector2.zero, Vector2.zero, 80f, 25f);
			if (currentVal != null)
			{
				(int, int) tuple3 = JsonConvert.DeserializeObject<(int, int)>(currentVal);
				_inputX.text = tuple3.Item1.ToString(CultureInfo.InvariantCulture);
				_inputY.text = tuple3.Item2.ToString(CultureInfo.InvariantCulture);
			}
			string lastX = _inputX.text;
			string lastY = _inputY.text;
			InputField inputX = _inputX;
			InputField inputY = _inputY;
			CharacterValidation characterValidation = (CharacterValidation)2;
			inputY.characterValidation = (CharacterValidation)2;
			inputX.characterValidation = characterValidation;
			((UnityEvent<string>)(object)_inputX.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastX == s))
				{
					lastX = s;
					((Selectable)apply).interactable = true;
				}
			});
			((UnityEvent<string>)(object)_inputY.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastY == s))
				{
					lastY = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			return _parent;
		}

		public override string GetValue()
		{
			if (!int.TryParse(_inputX.text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				result = 1;
			}
			if (!int.TryParse(_inputY.text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				result2 = 1;
			}
			return JsonConvert.SerializeObject((object)(result, result2));
		}
	}
	public class FloatConfigType : ConfigType<FloatConfigValue>
	{
		private float? _defaultValue;

		public FloatConfigType(string name, string id, Action<GameObject, FloatConfigValue> action, [CanBeNull] Action<GameObject, FloatConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public FloatConfigType WithDefaultValue(float value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new FloatConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new FloatConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			float value;
			try
			{
				value = Convert.ToSingle(data, CultureInfo.InvariantCulture);
			}
			catch (FormatException)
			{
				value = 9999999f;
			}
			return new FloatConfigValue(this, value);
		}
	}
	public class FloatConfigValue : ConfigValue<FloatConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private float <value>P;

		public FloatConfigValue(FloatConfigType type, float value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public float GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class FloatConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public FloatConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 120f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			_input.characterValidation = (CharacterValidation)2;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class IdConfigType : ConfigType<IdConfigValue>
	{
		[CanBeNull]
		private string _defaultValue;

		public IdConfigType(string name, string id, Action<GameObject, IdConfigValue> action, [CanBeNull] Action<GameObject, IdConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public IdConfigType WithDefaultValue(string value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return (_defaultValue == null) ? null : new IdConfigValue(this, _defaultValue);
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new IdConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new IdConfigValue(this, data);
		}
	}
	public class IdConfigValue : ConfigValue<IdConfigType>
	{
		public string Value;

		private string _extraId;

		public IdConfigValue(IdConfigType type, string value)
		{
			Value = value;
			base..ctor(type);
		}

		public string GetValue()
		{
			return Value + _extraId;
		}

		public string GetUnmodifiedValue()
		{
			return Value;
		}

		public override string SerializeValue()
		{
			return Value;
		}

		public override void Setup(GameObject obj, string extraId)
		{
			_extraId = extraId;
			base.Setup(obj, extraId);
		}
	}
	public class IdConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public IdConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 220f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public InputField GetField()
		{
			return _input;
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class IntConfigType : ConfigType<IntConfigValue>
	{
		private int? _defaultValue;

		public IntConfigType(string name, string id, Action<GameObject, IntConfigValue> action, [CanBeNull] Action<GameObject, IntConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public IntConfigType WithDefaultValue(int value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return _defaultValue.HasValue ? new IntConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new IntConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new IntConfigValue(this, Convert.ToInt32(data, CultureInfo.InvariantCulture));
		}
	}
	public class IntConfigValue : ConfigValue<IntConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private int <value>P;

		public IntConfigValue(IntConfigType type, int value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public int GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P.ToString(CultureInfo.InvariantCulture);
		}
	}
	public class IntConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public IntConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 120f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			_input.characterValidation = (CharacterValidation)1;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class StringConfigType : ConfigType<StringConfigValue>
	{
		[CanBeNull]
		private string _defaultValue;

		public StringConfigType(string name, string id, Action<GameObject, StringConfigValue> action, [CanBeNull] Action<GameObject, StringConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public StringConfigType WithDefaultValue(string value)
		{
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			return (_defaultValue == null) ? null : new StringConfigValue(this, _defaultValue);
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new StringConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			return new StringConfigValue(this, data);
		}
	}
	public class StringConfigValue : ConfigValue<StringConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string <value>P;

		public StringConfigValue(StringConfigType type, string value)
		{
			<value>P = value;
			base..ctor(type);
		}

		public string GetValue()
		{
			return <value>P;
		}

		public override string SerializeValue()
		{
			return <value>P;
		}
	}
	public class StringConfigElement : ConfigElement
	{
		private readonly InputField _input;

		public StringConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			(_input, _) = UIUtils.MakeTextbox("Config Input", parent, Vector2.op_Implicit(pos), Vector2.zero, Vector2.zero, 220f, 25f);
			if (currentVal != null)
			{
				_input.text = currentVal;
			}
			string last = _input.text;
			((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(last == s))
				{
					last = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			Transform transform = ((Component)_input).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public override string GetValue()
		{
			return _input.text;
		}
	}
	public class Vector2ConfigType : ConfigType<Vector2ConfigValue>
	{
		private Vector2? _defaultValue;

		public Vector2ConfigType(string name, string id, Action<GameObject, Vector2ConfigValue> action, [CanBeNull] Action<GameObject, Vector2ConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public Vector2ConfigType WithDefaultValue(Vector2 value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return _defaultValue.HasValue ? new Vector2ConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2ConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Vector2 value;
			try
			{
				value = JsonConvert.DeserializeObject<Vector2>(data);
			}
			catch
			{
				value = Vector2.zero;
			}
			return new Vector2ConfigValue(this, value);
		}
	}
	public class Vector2ConfigValue : ConfigValue<Vector2ConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Vector2 <value>P;

		public Vector2ConfigValue(Vector2ConfigType type, Vector2 value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			<value>P = value;
			base..ctor(type);
		}

		public Vector2 GetValue()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return <value>P;
		}

		public override string SerializeValue()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return JsonConvert.SerializeObject((object)<value>P);
		}
	}
	public class Vector2ConfigElement : ConfigElement
	{
		private readonly RectTransform _parent;

		private readonly InputField _inputX;

		private readonly InputField _inputY;

		public Vector2ConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0062: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Config Input");
			val.transform.parent = parent.transform;
			val.transform.localScale = Vector3.one;
			GameObject val2 = val;
			_parent = val2.RemoveOffset();
			_parent.anchoredPosition = Vector2.op_Implicit(pos);
			(_inputX, _) = UIUtils.MakeTextbox("X", val2, new Vector2(-17.5f, 0f), Vector2.zero, Vector2.zero, 80f, 25f);
			(_inputY, _) = UIUtils.MakeTextbox("Y", val2, new Vector2(17.5f, 0f), Vector2.zero, Vector2.zero, 80f, 25f);
			if (currentVal != null)
			{
				Vector2 val3 = JsonConvert.DeserializeObject<Vector2>(currentVal);
				_inputX.text = val3.x.ToString(CultureInfo.InvariantCulture);
				_inputY.text = val3.y.ToString(CultureInfo.InvariantCulture);
			}
			string lastX = _inputX.text;
			string lastY = _inputY.text;
			InputField inputX = _inputX;
			InputField inputY = _inputY;
			CharacterValidation characterValidation = (CharacterValidation)2;
			inputY.characterValidation = (CharacterValidation)2;
			inputX.characterValidation = characterValidation;
			((UnityEvent<string>)(object)_inputX.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastX == s))
				{
					lastX = s;
					((Selectable)apply).interactable = true;
				}
			});
			((UnityEvent<string>)(object)_inputY.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastY == s))
				{
					lastY = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			return _parent;
		}

		public override string GetValue()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			if (float.TryParse(_inputX.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				val.x = result;
			}
			if (float.TryParse(_inputY.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				val.y = result2;
			}
			return JsonConvert.SerializeObject((object)val);
		}
	}
	public class Vector3ConfigType : ConfigType<Vector3ConfigValue>
	{
		private Vector3? _defaultValue;

		public Vector3ConfigType(string name, string id, Action<GameObject, Vector3ConfigValue> action, [CanBeNull] Action<GameObject, Vector3ConfigValue, ConfigurationManager.PreviewContext> previewAction = null)
			: base(name, id, action, previewAction)
		{
		}

		public Vector3ConfigType WithDefaultValue(Vector3 value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_defaultValue = value;
			return this;
		}

		public override ConfigValue GetDefaultValue()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return _defaultValue.HasValue ? new Vector3ConfigValue(this, _defaultValue.Value) : null;
		}

		public override ConfigElement CreateInput(GameObject parent, Button apply, Vector3 pos, string currentVal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3ConfigElement(parent, apply, pos, currentVal);
		}

		public override ConfigValue Deserialize(string data)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Vector3 value;
			try
			{
				value = JsonConvert.DeserializeObject<Vector3>(data);
			}
			catch
			{
				value = Vector3.zero;
			}
			return new Vector3ConfigValue(this, value);
		}
	}
	public class Vector3ConfigValue : ConfigValue<Vector3ConfigType>
	{
		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Vector3 <value>P;

		public Vector3ConfigValue(Vector3ConfigType type, Vector3 value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			<value>P = value;
			base..ctor(type);
		}

		public Vector3 GetValue()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return <value>P;
		}

		public override string SerializeValue()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return JsonConvert.SerializeObject((object)<value>P);
		}
	}
	public class Vector3ConfigElement : ConfigElement
	{
		private readonly RectTransform _parent;

		private readonly InputField _inputX;

		private readonly InputField _inputY;

		private readonly InputField _inputZ;

		public Vector3ConfigElement(GameObject parent, Button apply, Vector3 pos, [CanBeNull] string currentVal)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0062: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Config Input");
			val.transform.parent = parent.transform;
			val.transform.localScale = Vector3.one;
			GameObject val2 = val;
			_parent = val2.RemoveOffset();
			_parent.anchoredPosition = Vector2.op_Implicit(pos);
			(_inputX, _) = UIUtils.MakeTextbox("X", val2, Vector2.op_Implicit(new Vector3(-35f, 0f)), Vector2.zero, Vector2.zero, 80f, 25f);
			(_inputY, _) = UIUtils.MakeTextbox("Y", val2, Vector2.zero, Vector2.zero, Vector2.zero, 80f, 25f);
			(_inputZ, _) = UIUtils.MakeTextbox("Z", val2, Vector2.op_Implicit(new Vector3(35f, 0f)), Vector2.zero, Vector2.zero, 80f, 25f);
			if (currentVal != null)
			{
				Vector3 val3 = JsonConvert.DeserializeObject<Vector3>(currentVal);
				_inputX.text = val3.x.ToString(CultureInfo.InvariantCulture);
				_inputY.text = val3.y.ToString(CultureInfo.InvariantCulture);
				_inputZ.text = val3.z.ToString(CultureInfo.InvariantCulture);
			}
			string lastX = _inputX.text;
			string lastY = _inputY.text;
			string lastZ = _inputZ.text;
			InputField inputX = _inputX;
			InputField inputY = _inputY;
			InputField inputZ = _inputZ;
			CharacterValidation val4 = (CharacterValidation)2;
			inputZ.characterValidation = (CharacterValidation)2;
			inputX.characterValidation = (inputY.characterValidation = val4);
			((UnityEvent<string>)(object)_inputX.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastX == s))
				{
					lastX = s;
					((Selectable)apply).interactable = true;
				}
			});
			((UnityEvent<string>)(object)_inputY.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastY == s))
				{
					lastY = s;
					((Selectable)apply).interactable = true;
				}
			});
			((UnityEvent<string>)(object)_inputZ.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				if (!(lastZ == s))
				{
					lastZ = s;
					((Selectable)apply).interactable = true;
				}
			});
		}

		public override RectTransform GetElement()
		{
			return _parent;
		}

		public override string GetValue()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			if (float.TryParse(_inputX.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				val.x = result;
			}
			if (float.TryParse(_inputY.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				val.y = result2;
			}
			if (float.TryParse(_inputZ.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				val.z = result3;
			}
			return JsonConvert.SerializeObject((object)val);
		}
	}
}
namespace Architect.Behaviour.Utility
{
	public class AudioPlayer : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DoPlay>d__21 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AudioPlayer <>4__this;

			private AtmosCue <cue>5__1;

			private ManagedAsset<AtmosCue> <asset>5__2;

			private MusicCue <cue>5__3;

			private ManagedAsset<MusicCue> <asset>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<cue>5__1 = null;
				<asset>5__2 = null;
				<cue>5__3 = null;
				<asset>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this.isAtmos)
					{
						if (AtmosCues.TryGetValue(<>4__this.cueId, out <asset>5__2))
						{
							<>2__current = <asset>5__2.Load();
							<>1__state = 1;
							return true;
						}
						if (!CustomAtmosCues.TryGetValue(<>4__this.cueId, out <cue>5__1))
						{
							return false;
						}
						goto IL_00c9;
					}
					if (MusicCues.TryGetValue(<>4__this.cueId, out <asset>5__4))
					{
						<>2__current = <asset>5__4.Load();
						<>1__state = 2;
						return true;
					}
					if (!CustomMusicCues.TryGetValue(<>4__this.cueId, out <cue>5__3))
					{
						return false;
					}
					goto IL_01c4;
				case 1:
					<>1__state = -1;
					<cue>5__1 = <asset>5__2.Handle.Result;
					goto IL_00c9;
				case 2:
					{
						<>1__state = -1;
						<cue>5__3 = <asset>5__4.Handle.Result;
						goto IL_01c4;
					}
					IL_01c4:
					_isUnlocked = true;
					ManagerSingleton<AudioManager>.Instance.ApplyMusicCue(<cue>5__3, 0f, 0f, true);
					ManagerSingleton<AudioManager>.Instance.ApplyMusicSnapshot(NormalSnapshot, 0f, 0f);
					GameManager.instance.sm.musicCue = <cue>5__3;
					GameManager.instance.sm.musicSnapshot = <cue>5__3.snapshot;
					<cue>5__3 = null;
					<asset>5__4 = null;
					break;
					IL_00c9:
					_isUnlocked = true;
					ManagerSingleton<AudioManager>.Instance.ApplyAtmosCue(<cue>5__1, 0f);
					AudioManager.TransitionToAtmosOverride(AtmosSnapshot, 0f);
					GameManager.instance.sm.atmosCue = <cue>5__1;
					GameManager.instance.sm.atmosSnapshot = <cue>5__1.snapshot;
					<cue>5__1 = null;
					<asset>5__2 = null;
					break;
				}
				_isUnlocked = false;
				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 isAtmos;

		public bool playOnStart;

		public bool lockMusic = true;

		public string cueId;

		public static readonly Dictionary<string, MusicCue> CustomMusicCues = new Dictionary<string, MusicCue>();

		public static readonly Dictionary<string, AtmosCue> CustomAtmosCues = new Dictionary<string, AtmosCue>();

		private static readonly Dictionary<string, ManagedAsset<MusicCue>> MusicCues = new Dictionary<string, ManagedAsset<MusicCue>>();

		private static readonly Dictionary<string, ManagedAsset<AtmosCue>> AtmosCues = new Dictionary<string, ManagedAsset<AtmosCue>>();

		private static readonly List<AudioPlayer> Players = new List<AudioPlayer>();

		private static bool _isUnlocked;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private static AudioMixerSnapshot <NormalSnapshot>k__BackingField;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private static AudioMixerSnapshot <AtmosSnapshot>k__BackingField;

		private static AudioMixerSnapshot NormalSnapshot => <NormalSnapshot>k__BackingField ?? (<NormalSnapshot>k__BackingField = ((IEnumerable<AudioMixerSnapshot>)Resources.FindObjectsOfTypeAll<AudioMixerSnapshot>()).FirstOrDefault((Func<AudioMixerSnapshot, bool>)((AudioMixerSnapshot o) => ((Object)o).name == "Normal" && Object.op_Implicit((Object)(object)o.audioMixer) && ((Object)o.audioMixer).name == "Music")));

		public static AudioMixerSnapshot AtmosSnapshot => <AtmosSnapshot>k__BackingField ?? (<AtmosSnapshot>k__BackingField = ((IEnumerable<AudioMixerSnapshot>)Resources.FindObjectsOfTypeAll<AudioMixerSnapshot>()).FirstOrDefault((Func<AudioMixerSnapshot, bool>)((AudioMixerSnapshot o) => ((Object)o).name == "at All Layers")));

		public static void Init()
		{
			Dictionary<string, List<string>> dictionary = JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(ResourceUtils.LoadTextResource("audioassets.json"));
			foreach (var (text2, list2) in dictionary)
			{
				foreach (string item in list2)
				{
					string key = item.Split("/")[^1].Split(".")[0];
					if (item.Contains("Music"))
					{
						MusicCues[key] = ManagedAsset<MusicCue>.FromNonSceneAsset(item, text2);
					}
					else
					{
						AtmosCues[key] = ManagedAsset<AtmosCue>.FromNonSceneAsset(item, text2);
					}
				}
			}
			typeof(AudioManager).Hook("ApplyAtmosCue", (Action<Action<AudioManager, AtmosCue, float, bool>, AudioManager, AtmosCue, float, bool>)delegate(Action<AudioManager, AtmosCue, float, bool> orig, AudioManager self, AtmosCue atmosCue, float transitionTime, bool markWaitForAtmos)
			{
				Players.RemoveAll((AudioPlayer i) => !Object.op_Implicit((Object)(object)i));
				if (Players.Count <= 0 || _isUnlocked)
				{
					orig(self, atmosCue, transitionTime, markWaitForAtmos);
				}
			}, typeof(AtmosCue), typeof(float), typeof(bool));
			typeof(AudioManager).Hook("ApplyMusicCue", (Action<Action<AudioManager, MusicCue, float, float, bool>, AudioManager, MusicCue, float, float, bool>)delegate(Action<AudioManager, MusicCue, float, float, bool> orig, AudioManager self, MusicCue musicCue, float delayTime, float transitionTime, bool markWaitForAtmos)
			{
				Players.RemoveAll((AudioPlayer i) => !Object.op_Implicit((Object)(object)i));
				if (Players.Count <= 0 || _isUnlocked)
				{
					orig(self, musicCue, delayTime, transitionTime, markWaitForAtmos);
				}
			}, typeof(MusicCue), typeof(float), typeof(float), typeof(bool));
			typeof(AudioManager).Hook("ApplyMusicSnapshot", (Action<Action<AudioManager, AudioMixerSnapshot, float, float, bool>, AudioManager, AudioMixerSnapshot, float, float, bool>)delegate(Action<AudioManager, AudioMixerSnapshot, float, float, bool> orig, AudioManager self, AudioMixerSnapshot snapshot, float delayTime, float transitionTime, bool blockMusicMarker)
			{
				Players.RemoveAll((AudioPlayer i) => !Object.op_Implicit((Object)(object)i));
				if (Players.Count <= 0 || _isUnlocked)
				{
					orig(self, snapshot, delayTime, transitionTime, blockMusicMarker);
				}
			}, typeof(AudioMixerSnapshot), typeof(float), typeof(float), typeof(bool));
		}

		private void OnEnable()
		{
			if (lockMusic)
			{
				Players.Add(this);
			}
		}

		private void OnDisable()
		{
			if (lockMusic)
			{
				Players.Remove(this);
			}
		}

		private void Start()
		{
			if (playOnStart)
			{
				Play();
			}
		}

		public void Play()
		{
			if (!Utility.IsNullOrWhiteSpace(cueId))
			{
				((MonoBehaviour)this).StartCoroutine(DoPlay());
			}
		}

		[IteratorStateMachine(typeof(<DoPlay>d__21))]
		private IEnumerator DoPlay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoPlay>d__21(0)
			{
				<>4__this = this
			};
		}
	}
	public class BlackThreader : MonoBehaviour
	{
		public class CustomBlackThreadState : BlackThreadState
		{
			public bool blockAttacks;

			public bool blockingAttack;

			public BlackThreadAttack customAttack;

			public GameObject source;

			private void Start()
			{
				if (!CustomStart())
				{
					((Behaviour)this).enabled = false;
					return;
				}
				blockingAttack = blockAttacks;
				base.attacks = (BlackThreadAttack[])(object)new BlackThreadAttack[1] { customAttack };
				((BlackThreadState)this).SetupThreaded(true);
			}

			private bool CustomStart()
			{
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				((BlackThreadState)this).GetSingFsm();
				BlackThreadData component = ((Component)this).GetComponent<BlackThreadData>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.OnBlackThread?.Invoke();
				}
				if (!Object.op_Implicit((Object)(object)base.singFsm))
				{
					tk2dSpriteAnimator component2 = ((Component)this).GetComponent<tk2dSpriteAnimator>();
					string animClip = "";
					if (Object.op_Implicit((Object)(object)component2))
					{
						animClip = (component2.GetClipByName("Sing") ?? component2.GetClipByName("Idle") ?? component2.currentClip ?? component2.DefaultClip).name;
					}
					PlayMakerFSM component3 = ((Component)this).GetComponent<PlayMakerFSM>();
					if (!Object.op_Implicit((Object)(object)component3))
					{
						return false;
					}
					component3.AddState("Sing");
					((BlackThreadState)this).GetSingFsm();
					if (!Object.op_Implicit((Object)(object)base.singFsm))
					{
						return false;
					}
					SingPatcher singPatcher = ((Component)this).gameObject.AddComponent<SingPatcher>();
					if (Object.op_Implicit((Object)(object)component))
					{
						singPatcher.SingCheck = component.SingCheck;
					}
					singPatcher.fsm = component3;
					singPatcher.bts = (BlackThreadState)(object)this;
					singPatcher.animator = component2;
					singPatcher.animClip = animClip;
					base.centreOffset = Vector2.zero;
				}
				if (base.hasStarted)
				{
					return false;
				}
				base.hasStarted = true;
				((BlackThreadState)this).OnAwake();
				base.isBlackThreadWorld = true;
				GameObject val = Object.Instantiate<GameObject>(customAttack.Prefab, ((Component)this).transform);
				val.transform.localPosition = Vector3.zero;
				val.SetActive(false);
				base.spawnedAttackObjs[customAttack] = val;
				base.chosenAttack = customAttack;
				base.hasChosenAttack = true;
				((BlackThreadState)this).PreSpawnBlackThreadEffects();
				((BlackThreadState)this).FirstThreadedSetUp();
				((BlackThreadState)this).BecomeThreadedNoSing();
				return true;
			}
		}

		public class BlackThreadData : MonoBehaviour
		{
			public Func<bool> SingCheck;

			public Action OnBlackThread;
		}

		private class SingPatcher : MonoBehaviour
		{
			public BlackThreadState bts;

			public PlayMakerFSM fsm;

			public tk2dSpriteAnimator animator;

			public string animClip;

			private bool _forcedSing;

			private string _lastStateName;

			private string _lastClip;

			public Func<bool> SingCheck;

			private void Update()
			{
				bool isInForcedSing = bts.IsInForcedSing;
				if (isInForcedSing == _forcedSing)
				{
					return;
				}
				if (isInForcedSing)
				{
					string activeStateName = fsm.ActiveStateName;
					if (!activeStateName.Contains("Idle") && !activeStateName.Contains("Walk") && !activeStateName.Contains("Stationary") && !activeStateName.Contains("Chase") && !(SingCheck?.Invoke() ?? false))
					{
						return;
					}
					_lastStateName = fsm.ActiveStateName;
					fsm.SetState("Sing");
					if (Object.op_Implicit((Object)(object)animator))
					{
						_lastClip = animator.currentClip.name;
						animator.Play(animClip);
					}
				}
				else
				{
					fsm.SetState(_lastStateName);
					if (Object.op_Implicit((Object)(object)animator))
					{
						animator.Play(_lastClip);
					}
				}
				_forcedSing = isInForcedSing;
			}
		}

		public string id;

		public int mode;

		public bool blockAttacks;

		public int sideEffects;

		public bool requireAct3;

		public float hpMultiplier = 1f;

		public float[] chances = new float[4];

		private int _attackIndex;

		private bool _blackThreaded;

		private CustomBlackThreadState _bts;

		public static void Init()
		{
			typeof(BlackThreadState).Hook("DoAttack", (Action<Action<BlackThreadState, BlackThreadAttack>, BlackThreadState, BlackThreadAttack>)delegate(Action<BlackThreadState, BlackThreadAttack> orig, BlackThreadState self, BlackThreadAttack attack)
			{
				if (self is CustomBlackThreadState customBlackThreadState)
				{
					if (customBlackThreadState.blockingAttack)
					{
						return;
					}
					if (customBlackThreadState.blockAttacks)
					{
						customBlackThreadState.blockingAttack = true;
					}
					customBlackThreadState.source.BroadcastEvent("OnAttack");
				}
				orig(self, attack);
			});
		}

		public void ForceAttack()
		{
			if (Object.op_Implicit((Object)(object)_bts))
			{
				_bts.blockingAttack = false;
				((BlackThreadState)_bts).queuedForceAttack = true;
			}
		}

		private void Start()
		{
			float num = 0f;
			float[] array = chances;
			foreach (float num2 in array)
			{
				num += num2;
			}
			float num3 = Random.Range(0f, num);
			for (int j = 0; j < 4; j++)
			{
				num3 -= chances[j];
				if (num3 <= 0f)
				{
					_attackIndex = j;
					break;
				}
			}
		}

		public void BlackThread(HealthManager hm = null)
		{
			if ((_blackThreaded && !Object.op_Implicit((Object)(object)hm)) || (requireAct3 && !PlayerData.instance.GetBool("blackThreadWorld")))
			{
				return;
			}
			_blackThreaded = true;
			if (!PlacementManager.TryGetValue(id, out var obj))
			{
				if (!Object.op_Implicit((Object)(object)hm))
				{
					return;
				}
				obj = ((Component)hm).gameObject;
			}
			if (Object.op_Implicit((Object)(object)obj))
			{
				ObjectDuplicator component = obj.GetComponent<ObjectDuplicator>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.blackThreader = this;
				}
				else
				{
					BlackThread(obj);
				}
			}
		}

		public void BlackThread(GameObject target)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			HealthManager componentInChildren = target.GetComponentInChildren<HealthManager>();
			EnemyFixers.FourthChorus component = target.GetComponent<EnemyFixers.FourthChorus>();
			if (!Object.op_Implicit((Object)(object)componentInChildren) || sideEffects != 0)
			{
				int num = sideEffects;
				if ((uint)num <= 1u)
				{
					DamageHero[] componentsInChildren = target.GetComponentsInChildren<DamageHero>(true);
					foreach (DamageHero val in componentsInChildren)
					{
						val.damagePropertyFlags = (DamagePropertyFlags)(val.damagePropertyFlags | 8);
					}
				}
				num = sideEffects;
				if ((num == 0 || num == 2) ? true : false)
				{
					SpriteRenderer[] componentsInChildren2 = target.GetComponentsInChildren<SpriteRenderer>(true);
					foreach (SpriteRenderer val2 in componentsInChildren2)
					{
						((Renderer)val2).material.EnableKeyword("BLACKTHREAD");
					}
				}
				num = sideEffects;
				if ((num == 0 || num == 2) ? true : false)
				{
					MeshRenderer[] componentsInChildren3 = target.GetComponentsInChildren<MeshRenderer>(true);
					foreach (MeshRenderer val3 in componentsInChildren3)
					{
						((Renderer)val3).material.EnableKeyword("BLACKTHREAD");
					}
				}
				num = sideEffects;
				if ((num == 0 || num == 3) ? true : false)
				{
					AudioSource[] componentsInChildren4 = target.GetComponentsInChildren<AudioSource>(true);
					foreach (AudioSource val4 in componentsInChildren4)
					{
						val4.outputAudioMixerGroup = Effects.BlackThreadVoiceMixerGroup;
					}
				}
				num = sideEffects;
				if ((num != 0 && num != 2) || 1 == 0)
				{
					return;
				}
				tk2dSprite[] componentsInChildren5 = target.GetComponentsInChildren<tk2dSprite>(true);
				foreach (tk2dSprite val5 in componentsInChildren5)
				{
					try
					{
						val5.EnableKeyword("BLACKTHREAD");
					}
					catch
					{
					}
				}
			}
			else
			{
				target = ((Component)componentInChildren).gameObject;
				_bts = target.AddComponent<CustomBlackThreadState>();
				_bts.source = ((Component)this).gameObject;
				_bts.customAttack = Effects.BlackThreadAttacksDefault[_attackIndex];
				((BlackThreadState)_bts).extraSpriteRenderers = target.GetComponentsInChildren<SpriteRenderer>(true);
				((BlackThreadState)_bts).extraMeshRenderers = target.GetComponentsInChildren<MeshRenderer>(true);
				if (Object.op_Implicit((Object)(object)component))
				{
					component.threaded = true;
				}
				((BlackThreadState)_bts).useCustomHPMultiplier = true;
				((BlackThreadState)_bts).customHPMultiplier = 1f;
				_bts.blockAttacks = blockAttacks;
				componentInChildren.hp = Mathf.FloorToInt((float)componentInChildren.hp * hpMultiplier);
				componentInChildren.blackThreadState = (BlackThreadState)(object)_bts;
				componentInChildren.hasBlackThreadState = true;
			}
		}

		private void Update()
		{
			if (mode == 0 && !_blackThreaded)
			{
				BlackThread();
			}
		}
	}
	public class CameraBorder : MonoBehaviour
	{
		private static readonly List<CameraBorder> Borders = new List<CameraBorder>();

		public int type;

		public int activeType;

		private void OnEnable()
		{
			Borders.Add(this);
		}

		private void OnDisable()
		{
			Borders.Remove(this);
		}

		public static void Init()
		{
			typeof(CameraController).Hook("LateUpdate", (Action<Action<CameraController>, CameraController>)delegate(Action<CameraController> orig, CameraController self)
			{
				//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)
				orig(self);
				((Component)self).transform.position = KeepWithinBounds(((Component)self).transform.position);
			});
		}

		public static Vector3 KeepWithinBounds(Vector3 position)
		{
			//IL_0067: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			foreach (CameraBorder item in Borders.Where((CameraBorder bord) => bord.activeType == 0 || bord.activeType == 1 != Binoculars.BinocularsActive))
			{
				switch (item.type)
				{
				case 0:
					if (position.x < ((Component)item).transform.position.x)
					{
						position.x = ((Component)item).transform.position.x;
					}
					break;
				case 1:
					if (position.x > ((Component)item).transform.position.x)
					{
						position.x = ((Component)item).transform.position.x;
					}
					break;
				case 2:
					if (position.y > ((Component)item).transform.position.y)
					{
						position.y = ((Component)item).transform.position.y;
					}
					break;
				case 3:
					if (position.y < ((Component)item).transform.position.y)
					{
						position.y = ((Component)item).transform.position.y;
					}
					break;
				case 4:
					position.x = Extensions.GetPositionX(((Component)item).transform);
					position.y = Extensions.GetPositionY(((Component)item).transform);
					break;
				}
			}
			return position;
		}
	}
	public class CameraRotator : MonoBehaviour
	{
		private static readonly List<CameraRotator> Rotators = new List<CameraRotator>();

		public static void Init()
		{
			typeof(CameraController).Hook("LateUpdate", (Action<Action<CameraController>, CameraController>)delegate(Action<CameraController> orig, CameraController self)
			{
				orig(self);
				Extensions.SetRotation2D(((Component)self).transform, Rotators.Sum((CameraRotator o) => 0f - Extensions.GetRotation2D(((Component)o).transform)));
			});
		}

		private void OnEnable()
		{
			Rotators.Add(this);
		}

		private void OnDisable()
		{
			Rotators.Remove(this);
		}
	}
	public class CameraShaker : MonoBehaviour
	{
		public int shakeType;

		public void Shake()
		{
			CameraManagerReference mainCameraShakeManager = Camera.MainCameraShakeManager;
			int num = shakeType;
			if (1 == 0)
			{
			}
			CameraShakeProfile val = (CameraShakeProfile)(num switch
			{
				0 => Camera.TinyShake, 
				1 => Camera.SmallShake, 
				2 => Camera.AverageShake, 
				_ => Camera.BigShake, 
			});
			if (1 == 0)
			{
			}
			mainCameraShakeManager.DoShake((ICameraShake)(object)val, (Object)(object)this, false, true, true);
		}
	}
	public class ChoiceDisplay : MonoBehaviour, IDisplayable
	{
		[CompilerGenerated]
		private sealed class <DoDisplay>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ChoiceDisplay <>4__this;

			private SavedItem <i>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = HeroController.instance.FreeControl((HeroController _) => InteractManager.CanInteract);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					if (<>4__this.useItem)
					{
						<i>5__1 = MiscUtils.GetSavedItem(<>4__this.item);
						if (Object.op_Implicit((Object)(object)<i>5__1))
						{
							DialogueYesNoBox.Open((Action)<>4__this.Yes, (Action)<>4__this.No, true, <>4__this.text, MiscUtils.GetSavedItem(<>4__this.item), <>4__this.cost, true, <>4__this.takeItem, (SavedItem)null);
							return false;
						}
						<i>5__1 = null;
					}
					DialogueYesNoBox.Open((Action)<>4__this.Yes, (Action)<>4__this.No, true, <>4__this.text, <>4__this.currencyType, <>4__this.cost, true, true, (SavedItem)null);
					return false;
				}
			}

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

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

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RegainControl();
					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 string text;

		public string item;

		public bool takeItem;

		public bool useItem;

		public CurrencyType currencyType = (CurrencyType)0;

		public int cost;

		public ScriptBlock Block;

		public void Display()
		{
			((MonoBehaviour)this).StartCoroutine(DoDisplay());
		}

		[IteratorStateMachine(typeof(<DoDisplay>d__8))]
		private IEnumerator DoDisplay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoDisplay>d__8(0)
			{
				<>4__this = this
			};
		}

		private void Yes()
		{
			if (Object.op_Implicit((Object)(object)this))
			{
				((MonoBehaviour)this).StartCoroutine(RegainControlDelayed());
				if (Block != null)
				{
					Block.Event("Yes");
				}
				else
				{
					((Component)this).gameObject.BroadcastEvent("Yes");
				}
			}
		}

		private void No()
		{
			if (Object.op_Implicit((Object)(object)this))
			{
				((MonoBehaviour)this).StartCoroutine(RegainControlDelayed());
				if (Block != null)
				{
					Block.Event("No");
				}
				else
				{
					((Component)this).gameObject.BroadcastEvent("No");
				}
			}
		}

		[IteratorStateMachine(typeof(<RegainControlDelayed>d__11))]
		private static IEnumerator RegainControlDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RegainControlDelayed>d__11(0);
		}
	}
	public class ComponentHook : MonoBehaviour
	{
		public bool recursive;

		public string id;

		public string componentName = string.Empty;

		public int mode;

		public string fieldName = string.Empty;

		private FieldInfo _fieldInfo;

		private bool _done;

		private Behaviour[] _components;

		public void Setup()
		{
			if (!PlacementManager.TryGetValue(id, out var obj))
			{
				obj = ObjectUtils.FindGameObject(id);
				if (!Object.op_Implicit((Object)(object)obj))
				{
					return;
				}
			}
			_components = (recursive ? obj.GetComponentsInChildren<Behaviour>() : obj.GetComponents<Behaviour>()).Where((Behaviour c) => ((object)c).GetType().Name == componentName).ToArray();
			Behaviour[] components = _components;
			foreach (Behaviour val in components)
			{
				if (mode != 3)
				{
					if (mode == 0)
					{
						Object.Destroy((Object)(object)val);
					}
					else
					{
						val.enabled = mode == 2;
					}
				}
				if (_fieldInfo == null)
				{
					_fieldInfo = ((object)val).GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
			}
		}

		public void SetValue(object data)
		{
			if (_fieldInfo == null)
			{
				return;
			}
			if (data is float num)
			{
				if (_fieldInfo.FieldType == typeof(int))
				{
					data = (int)num;
				}
				else if (_fieldInfo.FieldType == typeof(double))
				{
					data = (double)num;
				}
			}
			if (data.GetType() != _fieldInfo.FieldType)
			{
				return;
			}
			try
			{
				Behaviour[] components = _components;
				foreach (Behaviour val in components)
				{
					if (Object.op_Implicit((Object)(object)val))
					{
						_fieldInfo.SetValue(val, data);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private void Update()
		{
			if (!_done)
			{
				_done = true;
				Setup();
			}
		}
	}
	public class CustomGuidComponent : GuidComponent
	{
		public bool overrideAll;

		private void Update()
		{
			if (overrideAll)
			{
				overrideAll = false;
				HeroCorpseMarker[] array = HeroCorpseMarker._activeMarkers.Where((HeroCorpseMarker m) => !(m.guidComponent is CustomGuidComponent)).ToArray();
				foreach (HeroCorpseMarker val in array)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}
	}
	public class CustomHazardRespawnMarker : HazardRespawnMarker
	{
		private void Start()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			base.respawnFacingDirection = (FacingDirection)((!(Extensions.GetScaleX(((Component)this).transform) < 0f)) ? 1 : 2);
		}
	}
	public class CustomInteraction : InteractableBase
	{
		public static readonly string[] Labels = new string[25]
		{
			"Inspect", "Speak", "Listen", "Enter", "Ascend", "Rest", "Shop", "Travel", "Challenge", "Exit",
			"Descend", "Sit", "Trade", "Accept", "Watch", "Consume", "Track", "TurnIn", "Attack", "Give",
			"Take", "Claim", "Call", "Play", "Dive"
		};

		public float xOffset;

		public float yOffset;

		public bool hideOnInteract;

		public static void Init()
		{
			typeof(InteractManager).Hook("AddInteractible", new Action<Action<InteractableBase, Transform, Vector3>, InteractableBase, Transform, Vector3>(UseOffset));
		}

		private static void UseOffset(Action<InteractableBase, Transform, Vector3> orig, InteractableBase interactible, Transform transform, Vector3 promptOffset)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			CustomInteraction component = ((Component)interactible).GetComponent<CustomInteraction>();
			if (Object.op_Implicit((Object)(object)component))
			{
				promptOffset.x = component.xOffset;
				promptOffset.y = component.yOffset;
			}
			orig(interactible, transform, promptOffset);
		}

		public override void Interact()
		{
			((Component)this).gameObject.BroadcastEvent("OnInteract");
			if (hideOnInteract)
			{
				((InteractableBase)this).HideInteraction();
			}
		}
	}
	public class CustomPickup : MonoBehaviour
	{
		public string item = "";

		public bool ignoreObtained;

		public bool touch;

		public int persistence;

		private CollectableItemPickup _itemPickup;

		public static void Init()
		{
			typeof(CollectableItemPickup).Hook("CheckActivation", (Action<Action<CollectableItemPickup>, CollectableItemPickup>)delegate(Action<CollectableItemPickup> orig, CollectableItemPickup self)
			{
				CustomPickup componentInParent2 = ((Component)self).GetComponentInParent<CustomPickup>();
				if (!Object.op_Implicit((Object)(object)componentInParent2) || !componentInParent2.ignoreObtained || self.activatedRead)
				{
					orig(self);
				}
			});
			typeof(CollectableItemPickup).Hook("DoPickupAction", (Func<Func<CollectableItemPickup, bool, bool>, CollectableItemPickup, bool, bool>)delegate(Func<CollectableItemPickup, bool, bool> orig, CollectableItemPickup self, bool breakIfAtMax)
			{
				CustomPickup componentInParent = ((Component)self).GetComponentInParent<CustomPickup>();
				if (Object.op_Implicit((Object)(object)componentInParent))
				{
					breakIfAtMax = true;
					((Component)componentInParent).gameObject.BroadcastEvent("BeforePickup");
				}
				return orig(self, breakIfAtMax);
			});
		}

		private void Start()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			_itemPickup = Object.Instantiate<CollectableItemPickup>(touch ? Gameplay.CollectableItemPickupInstantPrefab : Gameplay.CollectableItemPickupPrefab, ((Component)this).gameObject.transform);
			Extensions.SetLocalPosition2D(((Component)_itemPickup).transform, Vector2.zero);
			((Object)_itemPickup).name = ((Object)this).name + " Pickup";
			switch (persistence)
			{
			case 0:
				((Component)_itemPickup).gameObject.RemoveComponent<PersistentBoolItem>();
				break;
			case 1:
				((PersistentItemData<bool>)(object)((Component)_itemPickup).GetComponent<PersistentBoolItem>().itemData).IsSemiPersistent = true;
				break;
			}
			SavedItem savedItem = MiscUtils.GetSavedItem(item);
			if (Object.op_Implicit((Object)(object)savedItem))
			{
				_itemPickup.item = savedItem;
			}
		}
	}
	public class CustomTransitionPoint : PreviewableBehaviour
	{
		public int pointType;

		public bool applyInEditMode = true;

		private static GameObject _wakeDoor;

		public static void Init()
		{
			typeof(TransitionPoint).Hook("GetGatePosition", (Func<Func<TransitionPoint, GatePosition>, TransitionPoint, GatePosition>)delegate(Func<TransitionPoint, GatePosition> orig, TransitionPoint self)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)self))
				{
					return (GatePosition)5;
				}
				CustomTransitionPoint componentInParent2 = ((Component)self).GetComponentInParent<CustomTransitionPoint>();
				return Object.op_Implicit((Object)(object)componentInParent2) ? componentInParent2.GetGatePosition() : orig(self);
			});
			typeof(TransitionPoint).Hook("PrepareEntry", (Action<Action<TransitionPoint>, TransitionPoint>)delegate(Action<TransitionPoint> orig, TransitionPoint self)
			{
				orig(self);
				CustomTransitionPoint componentInParent = ((Component)self).GetComponentInParent<CustomTransitionPoint>();
				if (Object.op_Implicit((Object)(object)componentInParent))
				{
					((Component)componentInParent).gameObject.BroadcastEvent("OnExit");
				}
			});
			PreloadManager.RegisterPreload(new BasicPreload("Memory_Coral_Tower", "Door Get Up/door_wakeInMemory", delegate(GameObject o)
			{
				((Component)o.transform.GetChild(0)).gameObject.SetActive(false);
				((Component)o.transform.GetChild(1)).gameObject.SetActive(false);
				_wakeDoor = o;
			}));
		}

		private void Start()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (isAPreview && (PrefabManager.InPrefabScene || !applyInEditMode))
			{
				((Component)this).gameObject.SetActive(false);
				return;
			}
			TransitionPoint component = ((Component)this).GetComponent<TransitionPoint>();
			SceneTeleportMap.AddTransitionGate(component.targetScene, component.entryPoint);
			((InteractableBase)component).InteractLabel = (PromptLabels)3;
			if (pointType == 5 && !(GameManager.instance.entryGateName != ((Object)this).name))
			{
				GameObject val = Object.Instantiate<GameObject>(_wakeDoor, ((Component)this).transform);
				val.transform.localPosition = Vector3.zero;
				string name = ((Object)this).name;
				((Object)val.transform).name = name;
				((Object)this).name = ((Object)this).name + "_parent";
			}
		}

		public GatePosition GetGatePosition()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			int num = pointType;
			if (1 == 0)
			{
			}
			GatePosition result = (GatePosition)(num switch
			{
				1 => 2, 
				2 => 1, 
				3 => 0, 
				4 => 3, 
				_ => 4, 
			});
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class EnemyHook : MonoBehaviour
	{
		public string path;

		public HealthManager hm;

		public int index;

		private void Start()
		{
			DoCheck();
		}

		public void Set(HealthManager manager)
		{
			if (Object.op_Implicit((Object)(object)manager))
			{
				hm = manager;
				Setup();
			}
		}

		public void DoCheck()
		{
			GameObject val = ObjectUtils.FindGameObject(path, index);
			if (Object.op_Implicit((Object)(object)val))
			{
				hm = val.GetComponent<HealthManager>();
			}
			if (Object.op_Implicit((Object)(object)hm))
			{
				Setup();
			}
		}

		private void Setup()
		{
			ObjectBlock.ObjectBlockReference[] components = ((Component)this).GetComponents<ObjectBlock.ObjectBlockReference>();
			foreach (ObjectBlock.ObjectBlockReference block in components)
			{
				if (!Object.op_Implicit((Object)(object)((Component)hm).GetComponents<ObjectBlock.ObjectBlockReference>().FirstOrDefault((ObjectBlock.ObjectBlockReference o) => o.Block == block.Block)))
				{
					((Component)hm).gameObject.AddComponent<ObjectBlock.ObjectBlockReference>().Block = block.Block;
					block.Spawns.Add(((Component)hm).gameObject);
				}
			}
		}
	}
	public class FsmHook : MonoBehaviour
	{
		public string targetId;

		public string fsmName;

		public string stateName;

		public int index;

		public bool inject;

		private PlayMakerFSM _fsm;

		private bool _setup;

		private string _state = string.Empty;

		private float _time;

		private FsmState _stateTarget;

		private FsmStateAction _action;

		public string GetState()
		{
			return _state;
		}

		public void SendEvent(string eventName)
		{
			Setup();
			if (Object.op_Implicit((Object)(object)_fsm))
			{
				_fsm.SendEvent(eventName);
			}
		}

		public float GetTime()
		{
			return Time.time - _time;
		}

		public void ClearEvents(bool all = false)
		{
			Setup();
			if (!Object.op_Implicit((Object)(object)_fsm))
			{
				return;
			}
			foreach (FsmState item in _fsm.FsmStates.Where((FsmState state) => state.Name == stateName || all))
			{
				item.transitions = Array.Empty<FsmTransition>();
			}
		}

		public void SetState()
		{
			Setup();
			if (Object.op_Implicit((Object)(object)_fsm))
			{
				_fsm.SetState(stateName);
			}
		}

		private void Setup()
		{
			if (Object.op_Implicit((Object)(object)_fsm))
			{
				return;
			}
			_setup = true;
			if (!PlacementManager.TryGetValue(targetId, out var obj) && !targetId.StartsWith("Hero_Hornet"))
			{
				GameObject val = ObjectUtils.FindGameObject(targetId, index);
				if (!Object.op_Implicit((Object)(object)val))
				{
					return;
				}
				obj = val;
			}
			if (!Object.op_Implicit((Object)(object)obj))
			{
				obj = ((Component)HeroController.instance).gameObject;
			}
			_time = Time.time;
			_fsm = ((IEnumerable<PlayMakerFSM>)obj.GetComponentsInChildren<PlayMakerFSM>()).FirstOrDefault((Func<PlayMakerFSM, bool>)((PlayMakerFSM o) => o.FsmName == fsmName));
			if (Object.op_Implicit((Object)(object)_fsm) && inject)
			{
				_stateTarget = _fsm.GetState(stateName);
				if (_stateTarget != null)
				{
					_stateTarget.AddAction(OnTarget, 0, everyFrame: false);
					_action = _stateTarget.actions[0];
				}
			}
		}

		private void OnDestroy()
		{
			if (_stateTarget != null)
			{
				List<FsmStateAction> list = _stateTarget.actions.ToList();
				list.Remove(_action);
				_stateTarget.actions = list.ToArray();
			}
		}

		public void OnTarget()
		{
			((Component)this).gameObject.BroadcastEvent("OnTarget");
		}

		private void Update()
		{
			if (!_setup)
			{
				Setup();
			}
			if (Object.op_Implicit((Object)(object)_fsm) && _state != _fsm.ActiveStateName)
			{
				_state = _fsm.ActiveStateName;
				_time = Time.time;
				((Component)this).gameObject.BroadcastEvent("OnChange");
				if (_state == stateName && !inject)
				{
					OnTarget();
				}
			}
		}
	}
	public interface IDisplayable
	{
		void Display();
	}
	public class KeyListener : MonoBehaviour
	{
		public KeyCode key = (KeyCode)0;

		private void Update()
		{
			//IL_0002: 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)
			if (Input.GetKeyDown(key))
			{
				EventManager.BroadcastEvent(((Component)this).gameObject, "KeyPressed");
			}
			if (Input.GetKeyUp(key))
			{
				EventManager.BroadcastEvent(((Component)this).gameObject, "KeyReleased");
			}
		}
	}
	public class Layerer : MonoBehaviour
	{
		public string target;

		public int layer;

		public bool recursive;

		public bool start;

		private GameObject _target;

		private void Start()
		{
			if (!PlacementManager.TryGetValue(target, out _target))
			{
				_target = ObjectUtils.FindGameObject(target);
			}
		}

		private void Update()
		{
			if (start)
			{
				Apply();
				start = false;
			}
		}

		public void Apply()
		{
			if (!Object.op_Implicit((Object)(object)_target))
			{
				return;
			}
			if (recursive)
			{
				Transform[] componentsInChildren = _target.GetComponentsInChildren<Transform>(true);
				foreach (Transform val in componentsInChildren)
				{
					((Component)val).gameObject.layer = layer;
				}
			}
			else
			{
				_target.layer = layer;
			}
		}
	}
	public class MapStateHook : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <FadeIn>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ScreenFaderUtils.Fade(new Color(0f, 0f, 0f, 1f), Color.clear, 1f);
					return false;
				}
			}

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

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

		private static readonly List<MapStateHook> MapStateHooks = new List<MapStateHook>();

		public bool memory;

		public static void Init()
		{
			typeof(GameManager).Hook("GetCurrentMapZoneEnum", (Func<Func<GameManager, MapZone>, GameManager, MapZone>)delegate(Func<GameManager, MapZone> orig, GameManager self)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: 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_002f: Invalid comparison between Unknown and I4
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Invalid comparison between Unknown and I4
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				MapZone val = orig(self);
				if (MapStateHooks.Count > 0)
				{
					bool flag = MapStateHooks[0].memory;
					if (((int)val == 21 || (int)val == 33) ? true : false)
					{
						if (!flag)
						{
							return (MapZone)0;
						}
					}
					else if (flag)
					{
						return (MapZone)33;
					}
				}
				return val;
			});
			typeof(GameManager).Hook("EnterHero", (Action<Action<GameManager>, GameManager>)delegate(Action<GameManager> orig, GameManager self)
			{
				if (MapStateHooks.Count > 0 && self.RespawningHero)
				{
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(FadeIn());
				}
				orig(self);
			});
		}

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

		private void OnEnable()
		{
			MapStateHooks.Add(this);
		}

		private void OnDisable()
		{
			MapStateHooks.Remove(this);
		}
	}
	public class MusicController : MonoBehaviour
	{
		private void Update()
		{
			GameManager.instance.noMusicSnapshot.TransitionTo(0f);
		}
	}
	public class ObjectAnchor : PreviewableBehaviour
	{
		public class SplineAnchor : MonoBehaviour
		{
			public SplineObjects.Spline spline;

			public GameObject anchor;

			public float startTime;

			public float time;

			private bool _started;

			private void LateUpdate()
			{
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: 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_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				if (!_started)
				{
					_started = true;
					return;
				}
				int num = ((SplineBase)spline.actualSpline).GetPointCount() - 1;
				if (time > (float)num)
				{
					time %= num;
					anchor.BroadcastEvent("OnTrackEnd");
				}
				int num2 = Mathf.FloorToInt(time) % num;
				Vector3 position = ((SplineBase)spline.actualSpline).GetPoint(num2).Position;
				Vector3 position2 = ((SplineBase)spline.actualSpline).GetPoint(num2 + 1).Position;
				Extensions.SetPosition2D(((Component)this).transform, Vector2.op_Implicit(Vector3.Lerp(position, position2, time % 1f) + ((Component)spline).transform.position));
				time += Time.deltaTime * spline.speed / Vector3.Distance(position, position2);
			}

			public void Reset()
			{
				time = startTime;
			}
		}

		public class StickPlayer : MonoBehaviour
		{
			public Transform target;

			private void OnCollisionEnter2D(Collision2D collision)
			{
				GameObject gameObject = collision.gameObject;
				if (gameObject.layer == 9)
				{
					HeroController component = gameObject.GetComponent<HeroController>();
					if (Object.op_Implicit((Object)(object)component))
					{
						component.SetHeroParent(target);
					}
					else
					{
						gameObject.transform.SetParent(target);
					}
					Rigidbody2D component2 = gameObject.GetComponent<Rigidbody2D>();
					if (Object.op_Implicit((Object)(object)component2))
					{
						component2.interpolation = (RigidbodyInterpolation2D)0;
					}
				}
			}

			private void OnCollisionExit2D(Collision2D collision)
			{
				GameObject gameObject = collision.gameObject;
				if (gameObject.layer == 9)
				{
					LeavePlayer(gameObject);
				}
			}
		}

		public class AnchorReference : MonoBehaviour
		{
			public int activeAnchors;
		}

		private static readonly Material TrailMaterial = new Material(Shader.Find("Sprites/Default"));

		public string targetId = "";

		public GameObject overrideTarget;

		public string parentId = "";

		public float trackDistance;

		public float startOffset;

		public float speed;

		public float rotationSpeed;

		public float smoothing;

		public float startRotation;

		public float pauseTime;

		public bool moving = true;

		public bool stickPlayer = true;

		public float rotation;

		private float _currentRotationSpeed;

		private float _currentSpeed;

		private bool _startFlipped;

		private bool _flipped;

		private float _offset;

		private float _pauseRemaining;

		private bool _setup;

		private bool _checkSetup;

		private Vector3 _startPos;

		private PositionConstraint _constraint;

		private ConstraintSource _constraintSource;

		private AnchorReference _anchorRef;

		private RigidbodyConstraints2D _rigidbodyConstraints;

		[CanBeNull]
		private Rigidbody2D _rb2d;

		private MonoBehaviour _disableWhenMoving;

		private Vector3 _previewPos;

		private bool _previewInMotion;

		private TrailRenderer _previewTrail;

		private SplineAnchor _splineAnchor;

		private void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (!isAPreview)
			{
				Transform transform = new GameObject("[Architect] Anchor Parent").transform;
				transform.position = ((Component)this).transform.position;
				((Component)this).transform.SetParent(transform, true);
			}
		}

		private void Setup()
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0597: Unknown result type (might be due to invalid IL or missing references)
			//IL_059c: Unknown result type (might be due to invalid IL or missing references)
			_setup = true;
			GameObject obj;
			if (Object.op_Implicit((Object)(object)overrideTarget))
			{
				obj = overrideTarget;
			}
			else if (!PlacementManager.TryGetValue(targetId, out obj))
			{
				if (_checkSetup)
				{
					return;
				}
				obj = ObjectUtils.FindGameObject(targetId);
				if (!Object.op_Implicit((Object)(object)obj))
				{
					_checkSetup = true;
					if (isAPreview)
					{
						_setup = false;
					}
					return;
				}
			}
			if (!isAPreview)
			{
				Prefab component = obj.GetComponent<Prefab>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((Component)this).gameObject.SetActive(false);
					foreach (GameObject spawn in component.spawns)
					{
						GameObject val = Object.Instantiate<GameObject>(((Component)this).gameObject);
						val.RemoveComponentsInChildren<ObjectBlock.ObjectBlockReference>();
						Transform transform = val.transform;
						Vector3 val2 = ((Component)this).transform.position - obj.transform.position + spawn.transform.position;
						float? num = 0f;
						transform.position = Extensions.Where(val2, (float?)null, (float?)null, num);
						val.GetComponent<ObjectAnchor>().overrideTarget = spawn;
						ObjectBlock.ObjectBlockReference[] components = ((Component)this).GetComponents<ObjectBlock.ObjectBlockReference>();
						ObjectBlock.ObjectBlockReference[] array = components;
						foreach (ObjectBlock.ObjectBlockReference objectBlockReference in array)
						{
							objectBlockReference.Spawns.Add(val);
							ObjectBlock.ObjectBlockReference objectBlockReference2 = val.AddComponent<ObjectBlock.ObjectBlockReference>();
							objectBlockReference2.canEvent = false;
							objectBlockReference2.Block = objectBlockReference.Block;
						}
						val.SetActive(true);
					}
					((Component)this).gameObject.SetActive(true);
				}
				if (PlacementManager.TryGetValue(parentId, out var obj2))
				{
					SplineObjects.SplinePoint component2 = obj2.GetComponent<SplineObjects.SplinePoint>();
					if (Object.op_Implicit((Object)(object)component2) && Object.op_Implicit((Object)(object)component2.spline))
					{
						SetupSpline(component2);
					}
					else
					{
						EnemyHook component3 = obj2.GetComponent<EnemyHook>();
						((Component)this).transform.parent.SetParent(Object.op_Implicit((Object)(object)component3) ? ((Component)component3.hm).transform : obj2.transform, true);
					}
				}
			}
			Reset();
			if (speed < 0f)
			{
				_startFlipped = true;
				_flipped = true;
			}
			bool flag = obj.layer == 8 && Object.op_Implicit((Object)(object)obj.GetComponent<Collider2D>());
			GameObject val3 = obj;
			Collider2D[] componentsInChildren = obj.GetComponentsInChildren<Collider2D>();
			foreach (Collider2D val4 in componentsInChildren)
			{
				if (flag)
				{
					break;
				}
				val3 = ((Component)val4).gameObject;
				flag = val3.layer == 8;
			}
			if (flag && stickPlayer)
			{
				if (!Object.op_Implicit((Object)(object)obj.transform.parent))
				{
					Transform transform2 = new GameObject("[Architect] Motion Parent").transform;
					obj.transform.position = Vector3.zero;
					obj.transform.SetParent(transform2);
				}
				val3.AddComponent<StickPlayer>().target = obj.transform.parent;
				obj = ((Component)obj.transform.parent).gameObject;
			}
			SplineBase[] componentsInChildren2 = obj.GetComponentsInChildren<SplineBase>();
			foreach (SplineBase val5 in componentsInChildren2)
			{
				val5.preventCulling = true;
			}
			if (Object.op_Implicit((Object)(object)obj.GetComponent<ObjectAnchor>()))
			{
				obj = ((Component)obj.transform.parent).gameObject;
			}
			_startPos = ((Component)this).transform.localPosition;
			_startPos.z = obj.transform.position.z;
			HingeJoint2D componentInChildren = obj.GetComponentInChildren<HingeJoint2D>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				_startPos += ((Component)componentInChildren).transform.position - obj.transform.position;
				obj = ((Component)componentInChildren).gameObject;
				((Component)this).transform.localPosition = _startPos;
			}
			_constraint = obj.GetOrAddComponent<PositionConstraint>();
			_anchorRef = obj.GetOrAddComponent<AnchorReference>();
			_disableWhenMoving = (MonoBehaviour)(object)obj.GetComponent<AmbientSway>();
			_rb2d = obj.GetComponentInChildren<Rigidbody2D>();
			ConstraintSource constraintSource = default(ConstraintSource);
			((ConstraintSource)(ref constraintSource)).sourceTransform = ((Component)this).transform;
			((ConstraintSource)(ref constraintSource)).weight = 1f;
			_constraintSource = constraintSource;
			_constraint.AddSource(_constraintSource);
			((Component)this).transform.localPosition = _startPos;
			if (isAPreview)
			{
				_previewTrail = obj.GetOrAddComponent<TrailRenderer>();
				_previewTrail.Clear();
				((Renderer)_previewTrail).material = TrailMaterial;
				_previewTrail.startWidth = 0.1f;
				_previewTrail.time = 60f;
				((Renderer)_previewTrail).enabled = false;
				_previewInMotion = false;
				return;
			}
			_constraint.constraintActive = true;
			_anchorRef.activeAnchors++;
			if (Object.op_Implicit((Object)(object)_disableWhenMoving))
			{
				((Behaviour)_disableWhenMoving).enabled = false;
			}
			if (Object.op_Implicit((Object)(object)_rb2d))
			{
				_rigidbodyConstraints = _rb2d.constraints;
				_rb2d.constraints = (RigidbodyConstraints2D)7;
			}
		}

		public void Reset()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (_flipped != _startFlipped)
			{
				_flipped = !_flipped;
				speed = 0f - speed;
				rotationSpeed = 0f - rotationSpeed;
			}
			_offset = startOffset;
			float num = startRotation;
			Quaternion val = ((Component)this).transform.rotation;
			rotation = num + ((Quaternion)(ref val)).eulerAngles.z;
			_currentSpeed = speed;
			if (Object.op_Implicit((Object)(object)_splineAnchor))
			{
				_splineAnchor.Reset();
			}
		}

		private void OnDisable()
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_constraint))
			{
				return;
			}
			_anchorRef.activeAnchors--;
			List<ConstraintSource> list = new List<ConstraintSource>();
			_constraint.GetSources(list);
			_constraint.SetSources(list.Where((ConstraintSource o) => (Object)(object)((ConstraintSource)(ref o)).sourceTransform != (Object)(object)((Component)this).transform).ToList());
			if (_anchorRef.activeAnchors <= 0)
			{
				_constraint.constraintActive = false;
				if (Object.op_Implicit((Object)(object)_disableWhenMoving))
				{
					((Behaviour)_disableWhenMoving).enabled = true;
				}
				if (Object.op_Implicit((Object)(object)_rb2d))
				{
					_rb2d.constraints = _rigidbodyConstraints;
				}
				if (isAPreview)
				{
					ReleasePreview();
				}
			}
		}

		private void OnEnable()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_constraint))
			{
				_anchorRef.activeAnchors++;
				_constraint.AddSource(_constraintSource);
				_constraint.constraintActive = true;
				if (Object.op_Implicit((Object)(object)_disableWhenMoving))
				{
					((Behaviour)_disableWhenMoving).enabled = false;
				}
				if (Object.op_Implicit((Object)(object)_rb2d))
				{
					_rb2d.constraints = (RigidbodyConstraints2D)7;
				}
			}
		}

		private void Update()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			if (!_setup || (!Object.op_Implicit((Object)(object)_constraint) && isAPreview && Settings.Preview.IsPressed))
			{
				Setup();
			}
			if (!Object.op_Implicit((Object)(object)_constraint))
			{
				return;
			}
			if (isAPreview)
			{
				if (!Settings.Preview.IsPressed)
				{
					ReleasePreview();
					return;
				}
				if (!_previewInMotion)
				{
					_previewPos = ((Component)_constraint).transform.localPosition;
					_constraint.constraintActive = true;
					ObjectPlacement.PreviewObject component = ((Component)_constraint).GetComponent<ObjectPlacement.PreviewObject>();
					if (Object.op_Implicit((Object)(object)component))
					{
						_constraint.translationOffset = component.offset;
					}
					_previewInMotion = true;
					_offset = startOffset;
					if (_flipped != _startFlipped)
					{
						_flipped = !_flipped;
						speed = 0f - speed;
						rotationSpeed = 0f - rotationSpeed;
					}
					_currentSpeed = speed;
					_currentRotationSpeed = rotationSpeed;
					rotation = startRotation;
					_pauseRemaining = 0f;
					_previewTrail.Clear();
				}
			}
			if (!moving && !isAPreview)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)_rb2d))
			{
				_rb2d.linearVelocity = Vector2.zero;
			}
			if (_pauseRemaining > 0f)
			{
				_pauseRemaining -= Time.deltaTime;
				if (!(_pauseRemaining < 0f))
				{
					return;
				}
				_offset += _currentSpeed * (0f - _pauseRemaining);
				_pauseRemaining = 0f;
			}
			if (_offset >= trackDistance && !_flipped)
			{
				_flipped = true;
				speed = 0f - speed;
				rotationSpeed = 0f - rotationSpeed;
			}
			else if (_offset <= 0f && _flipped)
			{
				_flipped = false;
				speed = 0f - speed;
				rotationSpeed = 0f - rotationSpeed;
			}
			float num = rotation * (MathF.PI / 180f);
			Vector3 localPosition = _startPos + new Vector3(Mathf.Cos(num), Mathf.Sin(num), 0f) * _offset;
			((Component)this).transform.localPosition = localPosition;
			float currentSpeed = _currentSpeed;
			_offset += _currentSpeed * Time.deltaTime;
			_currentSpeed = Mathf.Lerp(_currentSpeed, speed, (smoothing <= 0f) ? 1f : Mathf.Min(Time.deltaTime / smoothing, 1f));
			if ((currentSpeed < 0f && _currentSpeed > 0f) || (currentSpeed > 0f && _currentSpeed < 0f))
			{
				_pauseRemaining = pauseTime;
				if (!isAPreview)
				{
					((Component)this).gameObject.BroadcastEvent("OnReverse");
				}
			}
			_currentRotationSpeed = Mathf.Lerp(_currentRotationSpeed, rotationSpeed, (smoothing <= 0f) ? 1f : Mathf.Min(Time.deltaTime / smoothing, 1f));
			rotation += _currentRotationSpeed * Time.deltaTime;
			if (Object.op_Implicit((Object)(object)_previewTrail))
			{
				((Renderer)_previewTrail).enabled = true;
			}
		}

		private void ReleasePreview()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (_previewInMotion)
			{
				_constraint.constraintActive = false;
				((Component)_constraint).gameObject.transform.position = _previewPos;
				_previewInMotion = false;
				((Renderer)_previewTrail).enabled = false;
				_previewTrail.Clear();
			}
		}

		public static void Init()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			typeof(HeroController).Hook("TakeDamage", (Action<Action<HeroController, GameObject, CollisionSide, int, HazardType, DamagePropertyFlags>, HeroController, GameObject, CollisionSide, int, HazardType, DamagePropertyFlags>)delegate(Action<HeroController, GameObject, CollisionSide, int, HazardType, DamagePropertyFlags> orig, HeroController self, GameObject go, CollisionSide damageSide, int damageAmount, HazardType hazardType, DamagePropertyFlags damagePropertyFlags)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Invalid comparison between Unknown and I4
				//IL_0017: 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_001e: Invalid comparison between Unknown and I4
				orig(self, go, damageSide, damageAmount, hazardType, damagePropertyFlags);
				if ((int)hazardType != 1 && (int)hazardType != 0 && (int)hazardType != 8)
				{
					LeavePlayer(((Component)HeroController.instance).gameObject);
				}
			});
			TrailMaterial.SetColor(Shader.PropertyToID("_Color"), new Color(1f, 0f, 0f, 0.2f));
		}

		private static void LeavePlayer(GameObject obj)
		{
			HeroController component = obj.GetComponent<HeroController>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.SetHeroParent((Transform)null);
			}
			else
			{
				obj.transform.SetParent((Transform)null);
			}
			Rigidbody2D component2 = obj.GetComponent<Rigidbody2D>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				component2.interpolation = (RigidbodyInterpolation2D)1;
			}
		}

		private void SetupSpline(SplineObjects.SplinePoint sp)
		{
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(((Object)this).name + " Spline Anchor");
			Transform transform = val.transform;
			Vector3 position = ((Component)sp).transform.position;
			float? num = Extensions.GetPositionZ(((Component)this).transform);
			transform.position = Extensions.Where(position, (float?)null, (float?)null, num);
			GameObject val2 = val;
			_splineAnchor = val2.AddComponent<SplineAnchor>();
			_splineAnchor.anchor = ((Component)this).gameObject;
			if (sp.spline.splines.Contains(sp))
			{
				_splineAnchor.startTime = (sp.spline.splines.IndexOf(sp) + 1) * 25;
				_splineAnchor.Reset();
			}
			_splineAnchor.spline = sp.spline;
			PositionConstraint val3 = ((Component)((Component)this).transform.parent).gameObject.AddComponent<PositionConstraint>();
			ConstraintSource val4 = default(ConstraintSource);
			((ConstraintSource)(ref val4)).sourceTransform = val2.transform;
			((ConstraintSource)(ref val4)).weight = 1f;
			val3.AddSource(val4);
			val3.translationOffset = ((Component)this).transform.position - ((Component)sp).transform.position;
			val3.constraintActive = true;
		}
	}
	public class ObjectColourer : MonoBehaviour
	{
		private class SpriteFlashOld : MonoBehaviour
		{
			[CompilerGenerated]
			private sealed class <Restore>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public SpriteFlash self;

				public SpriteFlashOld <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0053: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = null;
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						self.SetParams(<>4__this.old.a, <>4__this.old);
						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 Color old = Color.clear;

			[IteratorStateMachine(typeof(<Restore>d__1))]
			public IEnumerator Restore(SpriteFlash self)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Restore>d__1(0)
				{
					<>4__this = this,
					self = self
				};
			}
		}

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

			private object <>2__current;

			public float fadeTime;

			public Color color;

			public bool forceAlpha;

			public ObjectColourer <>4__this;

			private MiscFixers.ColorLock <lk>5__1;

			private Renderer[] <>s__2;

			private int <>s__3;

			private Renderer <rend>5__4;

			private SpriteFlash <sf>5__5;

			private SpriteRenderer[] <>s__6;

			private int <>s__7;

			private SpriteRenderer <sr>5__8;

			private tk2dSprite[] <>s__9;

			private int <>s__10;

			private tk2dSprite <sr>5__11;

			private TintRendererGroup[] <>s__12;

			private int <>s__13;

			private TintRendererGroup <sr>5__14;

			private ParticleSystem[] <>s__15;

			private int <>s__16;

			private ParticleSystem <renderer>5__17;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<lk>5__1 = null;
				<>s__2 = null;
				<rend>5__4 = null;
				<sf>5__5 = null;
				<>s__6 = null;
				<sr>5__8 = null;
				<>s__9 = null;
				<sr>5__11 = null;
				<>s__12 = null;
				<sr>5__14 = null;
				<>s__15 = null;
				<renderer>5__17 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_048e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0498: Expected O, but got Unknown
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0429: Unknown result type (might be due to invalid IL or missing references)
				//IL_029e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0356: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<lk>5__1 = <>4__this.target.GetOrAddComponent<MiscFixers.ColorLock>();
					if (<lk>5__1.permanent)
					{
						return false;
					}
					((Behaviour)<lk>5__1).enabled = false;
					if (<>4__this.mode == 2)
					{
						if (!forceAlpha && !<>4__this.useAlphaByDefault)
						{
							color.a = 1f;
						}
						<>s__2 = <>4__this.target.GetComponentsInChildren<Renderer>(true);
						for (<>s__3 = 0; <>s__3 < <>s__2.Length; <>s__3++)
						{
							<rend>5__4 = <>s__2[<>s__3];
							<rend>5__4.material.shader = FlashShader;
							<sf>5__5 = ((Component)<rend>5__4).gameObject.GetOrAddComponent<SpriteFlash>();
							((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FadeRoutine(fadeTime, <sf>5__5, color));
							<sf>5__5 = null;
							<rend>5__4 = null;
						}
						<>s__2 = null;
					}
					else
					{
						if (<>4__this.particles != 2)
						{
							<>s__6 = <>4__this.target.GetComponentsInChildren<SpriteRenderer>(true);
							for (<>s__7 = 0; <>s__7 < <>s__6.Length; <>s__7++)
							{
								<sr>5__8 = <>s__6[<>s__7];
								<>4__this._current++;
								((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FadeRoutine(fadeTime, <sr>5__8, color, <>4__this.useAlphaByDefault | forceAlpha));
								<sr>5__8 = null;
							}
							<>s__6 = null;
							<>s__9 = <>4__this.target.GetComponentsInChildren<tk2dSprite>(true);
							for (<>s__10 = 0; <>s__10 < <>s__9.Length; <>s__10++)
							{
								<sr>5__11 = <>s__9[<>s__10];
								<>4__this._current++;
								((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FadeRoutine(fadeTime, <sr>5__11, color, <>4__this.useAlphaByDefault | forceAlpha));
								<sr>5__11 = null;
							}
							<>s__9 = null;
							<>s__12 = <>4__this.target.GetComponentsInChildren<TintRendererGroup>(true);
							for (<>s__13 = 0; <>s__13 < <>s__12.Length; <>s__13++)
							{
								<sr>5__14 = <>s__12[<>s__13];
								<>4__this._current++;
								((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FadeRoutine(fadeTime, <sr>5__14, color, <>4__this.useAlphaByDefault | forceAlpha));
								<sr>5__14 = null;
							}
							<>s__12 = null;
						}
						if (<>4__this.particles != 1)
						{
							<>s__15 = <>4__this.target.GetComponentsInChildren<ParticleSystem>(true);
							for (<>s__16 = 0; <>s__16 < <>s__15.Length; <>s__16++)
							{
								<renderer>5__17 = <>s__15[<>s__16];
								<>4__this._current++;
								((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FadeRoutine(fadeTime, <renderer>5__17, color, <>4__this.useAlphaByDefault | forceAlpha));
								<renderer>5__17 = null;
							}
							<>s__15 = null;
						}
					}
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>4__this._current == 0));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Behaviour)<lk>5__1).enabled = true;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public float fadeTime;

			public SpriteFlash sr;

			public Color color;

			public ObjectColourer <>4__this;

			private float <time>5__1;

			private SpriteFlashOld <old>5__2;

			private Color <start>5__3;

			private Color <col>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__1 = 0f;
					<old>5__2 = ((Component)sr).gameObject.GetOrAddComponent<SpriteFlashOld>();
					<start>5__3 = <old>5__2.old;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__1 < fadeTime)
				{
					if (!Object.op_Implicit((Object)(object)sr))
					{
						return false;
					}
					<col>5__4 = Color.Lerp(<start>5__3, color, <time>5__1 / fadeTime);
					sr.SetParams(<col>5__4.a, <col>5__4);
					<old>5__2.old = <col>5__4;
					<time>5__1 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				sr.SetParams(color.a, color);
				<old>5__2.old = color;
				<>4__this._current--;
				return false;
			}

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

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

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

			private object <>2__current;

			public float fadeTime;

			public SpriteRenderer sr;

			public Color color;

			public bool useAlpha;

			public ObjectColourer <>4__this;

			private float <time>5__1;

			private Material <mat>5__2;

			private Color <start>5__3;

			private Color <end>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: 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_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__1 = 0f;
					<mat>5__2 = ((Renderer)sr).material;
					<start>5__3 = <mat>5__2.color * sr.color;
					sr.color = Color.white;
					<end>5__4 = ((<>4__this.mode == 0) ? (<start>5__3 * color) : color);
					if (!useAlpha)
					{
						<end>5__4.a = <start>5__3.a;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__1 < fadeTime)
				{
					if (!Object.op_Implicit((Object)(object)<mat>5__2))
					{
						return false;
					}
					<mat>5__2.color = Color.Lerp(<start>5__3, <end>5__4, <time>5__1 / fadeTime);
					<time>5__1 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<mat>5__2.color = <end>5__4;
				<>4__this._current--;
				return false;
			}

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

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

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

			private object <>2__current;

			public float fadeTime;

			public tk2dSprite sr;

			public Color color;

			public bool useAlpha;

			public ObjectColourer <>4__this;

			private float <time>5__1;

			private Color <start>5__2;

			private Color <end>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__1 = 0f;
					<start>5__2 = ((tk2dBaseSprite)sr).color;
					<end>5__3 = ((<>4__this.mode == 0) ? (<start>5__2 * color) : color);
					if (!useAlpha)
					{
						<end>5__3.a = <start>5__2.a;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__1 < fadeTime)
				{
					if (!Object.op_Implicit((Object)(object)sr))
					{
						return false;
					}
					((tk2dBaseSprite)sr).color = Color.Lerp(<start>5__2, <end>5__3, <time>5__1 / fadeTime);
					<time>5__1 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((tk2dBaseSprite)sr).color = <end>5__3;
				<>4__this._current--;
				return false;
			}

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

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

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

			private object <>2__current;

			public float fadeTime;

			public TintRendererGroup sr;

			public Color color;

			public bool useAlpha;

			public ObjectColourer <>4__this;

			private float <time>5__1;

			private Color <start>5__2;

			private Color <end>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__1 = 0f;
					<start>5__2 = sr.color;
					<end>5__3 = ((<>4__this.mode == 0) ? (<start>5__2 * color) : color);
					if (!useAlpha)
					{
						<end>5__3.a = <start>5__2.a;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__1 < fadeTime)
				{
					if (!Object.op_Implicit((Object)(object)sr))
					{
						return false;
					}
					sr.color = Color.Lerp(<start>5__2, <end>5__3, <time>5__1 / fadeTime);
					((Behaviour)sr).enabled = true;
					<time>5__1 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				sr.color = <end>5__3;
				((Behaviour)sr).enabled = true;
				<>4__this._current--;
				return false;
			}

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

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

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

			private object <>2__current;

			public float fadeTime;

			public ParticleSystem sr;

			public Color color;

			public bool useAlpha;

			public ObjectColourer <>4__this;

			private float <time>5__1;

			private MainModule <main>5__2;

			private Color <start>5__3;

			private Color <end>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				<main>5__2 = default(MainModule);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: 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_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<time>5__1 = 0f;
					<main>5__2 = sr.main;
					MinMaxGradient startColor = ((MainModule)(ref <main>5__2)).startColor;
					<start>5__3 = ((MinMaxGradient)(ref startColor)).color;
					<end>5__4 = ((<>4__this.mode == 0) ? (<start>5__3 * color) : color);
					if (!useAlpha)
					{
						<end>5__4.a = <start>5__3.a;
					}
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__1 < fadeTime)
				{
					if (!Object.op_Implicit((Object)(object)sr))
					{
						return false;
					}
					((MainModule)(ref <main>5__2)).startColor = MinMaxGradient.op_Implicit(Color.Lerp(<start>5__3, <end>5__4, <time>5__1 / fadeTime));
					<time>5__1 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((MainModule)(ref <main>5__2)).startColor = MinMaxGradient.op_Implicit(<end>5__4);
				<>4__this._current--;
				return false;
			}

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

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

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

			private object <>2__current;

			public Func<SpriteFlash, float, float, float, float, float, bool, int, RepeatingFlash, IEnumerator> orig;

			public SpriteFlash self;

			public float amount;

			public float timeUp;

			public float stayTime;

			public float timeDown;

			public float stayDownTime;

			public bool repeating;

			public int repeatTimes;

			public RepeatingFlash repeatingFlash;

			private SpriteFlashOld <sfo>5__1;

			private IEnumerator <o>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sfo>5__1 = null;
				<o>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<sfo>5__1 = ((Component)self).GetComponent<SpriteFlashOld>();
					if (Object.op_Implicit((Object)(object)<sfo>5__1) && Mathf.Approximately(<sfo>5__1.old.a, 1f))
					{
						((MonoBehaviour)<sfo>5__1).StartCoroutine(<sfo>5__1.Restore(self));
						return false;
					}
					<o>5__2 = orig(self, amount, timeUp, stayTime, timeDown, stayDownTime, repeating, repeatTimes, repeatingFlash);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<o>5__2.MoveNext())
				{
					<>2__current = <o>5__2.Current;
					<>1__state = 1;
					return true;
				}
				if (Object.op_Implicit((Object)(object)<sfo>5__1))
				{
					self.SetParams(<sfo>5__1.old.a, <sfo>5__1.old);
				}
				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 string targetId;

		public bool useAlphaByDefault;

		public int mode;

		public float r;

		public float g;

		public float b;

		public float a;

		public bool startApplied;

		public int particles;

		public GameObject target;

		private Color _color;

		private bool _setup;

		private int _current;

		private static readonly Shader FlashShader = Resources.FindObjectsOfTypeAll<Shader>().First((Shader o) => ((Object)o).name == "Sprites/Default-ColorFlash");

		public Color Colour
		{
			set
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				r = value.r;
				g = value.g;
				b = value.b;
				a = value.a;
			}
		}

		public static void Init()
		{
			typeof(SpriteFlash).Hook("Awake", (Action<Action<SpriteFlash>, SpriteFlash>)delegate(Action<SpriteFlash> orig, SpriteFlash self)
			{
				SpriteFlash val = self;
				if (val.children == null)
				{
					val.children = new List<SpriteFlash>();
				}
				val = self;
				if (val.parents == null)
				{
					val.parents = new List<SpriteFlash>();
				}
				orig(self);
			});
			typeof(SpriteFlash).Hook("FlashRoutine", new Func<Func<SpriteFlash, float, float, float, float, float, bool, int, RepeatingFlash, IEnumerator>, SpriteFlash, float, float, float, float, float, bool, int, RepeatingFlash, IEnumerator>(FlashRoutine));
		}

		[IteratorStateMachine(typeof(<FlashRoutine>d__15))]
		private static IEnumerator FlashRoutine(Func<SpriteFlash, float, float, float, float, float, bool, int, RepeatingFlash, IEnumerator> orig, SpriteFlash self, float amount, float timeUp, float stayTime, float timeDown, float stayDownTime, bool repeating, int repeatTimes, RepeatingFlash repeatingFlash)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FlashRoutine>d__15(0)
			{
				orig = orig,
				self = self,
				amount = amount,
				timeUp = timeUp,
				stayTime = stayTime,
				timeDown = timeDown,
				stayDownTime = stayDownTime,
				repeating = repeating,
				repeatTimes = repeatTimes,
				repeatingFlash = repeatingFlash
			};
		}

		private void Update()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			if (_setup)
			{
				return;
			}
			_setup = true;
			_color = new Color(r, g, b, a);
			GameObject obj;
			if (Object.op_Implicit((Object)(object)target))
			{
				obj = target;
			}
			else if (!PlacementManager.TryGetValue(targetId, out obj))
			{
				obj = ObjectUtils.FindGameObject(targetId);
				if (!Object.op_Implicit((Object)(object)obj))
				{
					return;
				}
			}
			Prefab component = obj.GetComponent<Prefab>();
			if (Object.op_Implicit((Object)(object)component))
			{
				foreach (GameObject spawn in component.spawns)
				{
					GameObject val = Object.Instantiate<GameObject>(((Component)this).gameObject);
					val.transform.position = ((Component)this).transform.position - obj.transform.position + spawn.transform.position;
					val.GetComponent<ObjectColourer>().target = spawn;
					ObjectBlock.ObjectBlockReference[] components = ((Component)this).GetComponents<ObjectBlock.ObjectBlockReference>();
					ObjectBlock.ObjectBlockReference[] array = components;
					foreach (ObjectBlock.ObjectBlockReference objectBlockReference in array)
					{
						objectBlockReference.Spawns.Add(val);
						val.AddComponent<ObjectBlock.ObjectBlockReference>().Block = objectBlockReference.Block;
					}
				}
				return;
			}
			target = obj;
			if (startApplied)
			{
				Apply(0f);
			}
		}

		public void Apply(float fadeTime, Color? color = null)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)target))
			{
				((MonoBehaviour)this).StartCoroutine(DoApply(fadeTime, (Color)(((??)color) ?? _color), color.HasValue));
			}
		}

		public void StopFade()
		{
			((MonoBehaviour)this).StopAllCoroutines();
			_current = 0;
		}

		[IteratorStateMachine(typeof(<DoApply>d__21))]
		public IEnumerator DoApply(float fadeTime, Color color, bool forceAlpha)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoApply>d__21(0)
			{
				<>4__this = this,
				fadeTime = fadeTime,
				color = color,
				forceAlpha = forceAlpha
			};
		}

		[IteratorStateMachine(typeof(<FadeRoutine>d__23))]
		private IEnumerator FadeRoutine(float fadeTime, SpriteFlash sr, Color color)
		{
			//IL_001c: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeRoutine>d__23(0)
			{
				<>4__this = this,
				fadeTime = fadeTime,
				sr = sr,
				color = color
			};
		}

		[IteratorStateMachine(typeof(<FadeRoutine>d__24))]
		private IEnumerator FadeRoutine(float fadeTime, SpriteRenderer sr, Color color, bool useAlpha)
		{
			//IL_001c: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeRoutine>d__24(0)
			{
				<>4__this = this,
				fadeTime = fadeTime,
				sr = sr,
				color = color,
				useAlpha = useAlpha
			};
		}

		[IteratorStateMachine(typeof(<FadeRoutine>d__25))]
		private IEnumerator FadeRoutine(float fadeTime, tk2dSprite sr, Color color, bool useAlpha)
		{
			//IL_001c: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeRoutine>d__25(0)
			{
				<>4__this = this,
				fadeTime = fadeTime,
				sr = sr,
				color = color,
				useAlpha = useAlpha
			};
		}

		[IteratorStateMachine(typeof(<FadeRoutine>d__26))]
		private IEnumerator FadeRoutine(float fadeTime, TintRendererGroup sr, Color color, bool useAlpha)
		{
			//IL_001c: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeRoutine>d__26(0)
			{
				<>4__this = this,
				fadeTime = fadeTime,
				sr = sr,
				color = color,
				useAlpha = useAlpha
			};
		}

		[IteratorStateMachine(typeof(<FadeRoutine>d__27))]
		private IEnumerator FadeRoutine(float fadeTime, ParticleSystem sr, Color color, bool useAlpha)
		{
			//IL_001c: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeRoutine>d__27(0)
			{
				<>4__this = this,
				fadeTime = fadeTime,
				sr = sr,
				color = color,
				useAlpha = useAlpha
			};
		}
	}
	public class ObjectDuplicator : MonoBehaviour
	{
		public string id;

		public BlackThreader blackThreader;

		public Plasmifier plasmifier;

		public Shielder shielder;

		private ObjectPlacement _placement;

		public void Duplicate()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (_placement == null)
			{
				_placement = PlacementManager.GetPlacement(id);
				if (_placement == null)
				{
					return;
				}
			}
			GameObject val = _placement.SpawnObject(((Component)this).transform.position);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			((Object)val).name = ((Object)val).name + " Copy " + Guid.NewGuid();
			val.RemoveComponent<PersistentBoolItem>();
			val.SetActive(true);
			GameObject val2 = PlacementManager.Objects[id];
			if (Object.op_Implicit((Object)(object)val2))
			{
				ObjectBlock.ObjectBlockReference[] components = val2.GetComponents<ObjectBlock.ObjectBlockReference>();
				ObjectBlock.ObjectBlockReference[] array = components;
				foreach (ObjectBlock.ObjectBlockReference objectBlockReference in array)
				{
					objectBlockReference.Spawns.Add(val);
					val.AddComponent<ObjectBlock.ObjectBlockReference>().Block = objectBlockReference.Block;
				}
				if (Object.op_Implicit((Object)(object)blackThreader))
				{
					blackThreader.BlackThread(val);
				}
				if (Object.op_Implicit((Object)(object)plasmifier))
				{
					plasmifier.Plasmify(val);
				}
				if (Object.op_Implicit((Object)(object)shielder))
				{
					shielder.Shield(val);
				}
			}
		}
	}
	public class ObjectHook : PreviewableBehaviour
	{
		public string path;

		public string prefabPath;

		public string childPath;

		public GameObject o;

		public int start;

		public int index;

		private bool _targetingCustom;

		public void FindObject()
		{
			if (Utility.IsNullOrWhiteSpace(path) || Object.op_Implicit((Object)(object)o))
			{
				return;
			}
			if (PlacementManager.TryGetValue(prefabPath, out o))
			{
				_targetingCustom = true;
			}
			else
			{
				o = ObjectUtils.FindGameObject(path, index);
			}
			if (!Object.op_Implicit((Object)(object)o) || Utility.IsNullOrWhiteSpace(childPath))
			{
				return;
			}
			string[] array = childPath.Split("/");
			string[] array2 = array;
			foreach (string text in array2)
			{
				Transform val = o.transform.Find(text);
				if (!Object.op_Implicit((Object)(object)val))
				{
					break;
				}
				o = ((Component)val).gameObject;
			}
		}

		private void Start()
		{
			FindObject();
			if (Object.op_Implicit((Object)(object)o) && (!isAPreview || !_targetingCustom))
			{
				switch (start)
				{
				case 1:
					o.SetActive(false);
					break;
				case 2:
					o.SetActive(true);
					break;
				}
			}
		}
	}
	public class ObjectMover : MonoBehaviour
	{
		public string targetId = "";

		public float xOffset;

		public float yOffset;

		public float rotation;

		public bool moveX = true;

		public bool moveY = true;

		public int moveMode;

		public string moveTarget = "";

		public bool clearVelocity;

		public GameObject overrideTarget;

		private bool _setup;

		private Transform _source;

		private GameObject _target;

		private Rigidbody2D _rb2d;

		private void Update()
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			if (_setup)
			{
				return;
			}
			_setup = true;
			if (Object.op_Implicit((Object)(object)overrideTarget))
			{
				_target = overrideTarget;
			}
			if (!Object.op_Implicit((Object)(object)_target) && !PlacementManager.TryGetValue(targetId, out _target))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)_target.GetComponent<ObjectAnchor>()))
			{
				_target = ((Component)_target.transform.parent).gameObject;
				if (!Object.op_Implicit((Object)(object)_target))
				{
					_setup = false;
					return;
				}
			}
			if (PlacementManager.TryGetValue(moveTarget, out var obj))
			{
				_source = obj.transform;
			}
			else
			{
				int num = moveMode;
				if (1 == 0)
				{
				}
				Transform transform;
				switch (num)
				{
				case 0:
					transform = ((Component)this).transform;
					break;
				case 1:
					transform = _target.transform;
					break;
				case 2:
					transform = HeroController.instance.transform;
					break;
				default:
				{
					GameObject val = new GameObject("[Architect] Origin");
					val.transform.position = Vector3.zero;
					transform = val.transform;
					break;
				}
				}
				if (1 == 0)
				{
				}
				_source = transform;
			}
			Prefab component = _target.GetComponent<Prefab>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((Component)this).gameObject.SetActive(false);
				foreach (GameObject spawn in component.spawns)
				{
					GameObject val2 = Object.Instantiate<GameObject>(((Component)this).gameObject);
					val2.RemoveComponentsInChildren<ObjectBlock.ObjectBlockReference>();
					Transform transform2 = val2.transform;
					Vector3 val3 = ((Component)this).transform.position - _target.transform.position + spawn.transform.position;
					float? num2 = 0f;
					transform2.position = Extensions.Where(val3, (float?)null, (float?)null, num2);
					val2.GetComponent<ObjectMover>().overrideTarget = spawn;
					ObjectBlock.ObjectBlockReference[] components = ((Component)this).GetComponents<ObjectBlock.ObjectBlockReference>();
					ObjectBlock.ObjectBlockReference[] array = components;
					foreach (ObjectBlock.ObjectBlockReference objectBlockReference in array)
					{
						objectBlockReference.Spawns.Add(val2);
						ObjectBlock.ObjectBlockReference objectBlockReference2 = val2.AddComponent<ObjectBlock.ObjectBlockReference>();
						objectBlockReference2.canEvent = false;
						objectBlockReference2.Block = objectBlockReference.Block;
					}
					val2.SetActive(true);
				}
				((Component)this).gameObject.SetActive(true);
			}
			if (clearVelocity)
			{
				_rb2d = _target.GetComponent<Rigidbody2D>();
				if (!Object.op_Implicit((Object)(object)_rb2d))
				{
					clearVelocity = false;
				}
			}
		}

		public void Move(float eX, float eY, float eRot)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)_target) && Object.op_Implicit((Object)(object)_source))
			{
				if (clearVelocity)
				{
					_rb2d.linearVelocity = Vector2.zero;
				}
				Vector3 eulerAngles = _source.eulerAngles;
				eulerAngles.z += rotation + eRot;
				if (moveX)
				{
					Extensions.SetPositionX(_target.transform, _source.position.x + xOffset + eX);
				}
				if (moveY)
				{
					Extensions.SetPositionY(_target.transform, _source.position.y + yOffset + eY);
				}
				_target.transform.eulerAngles = eulerAngles;
			}
		}
	}
	public class ObjectRemover : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DoEnable>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ObjectRemover <>4__this;

			private Disabler[] <>s__1;

			private int <>s__2;

			private Disabler <obj>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (GameManager.instance.IsFirstLevelForPlayer)
					{
						<>2__current = (object)new WaitUntil((Func<bool>)(() => GameManager.instance.timeInScene > 0.8f));
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<>4__this._toggle = UtilityObjects.GetObjects(<>4__this);
				<>s__1 = <>4__this._toggle;
				for (<>s__2 = 0; <>s__2 < <>s__1.Length; <>s__2++)
				{
					<obj>5__3 = <>s__1[<>s__2];
					if (Object.op_Implicit((Object)(object)<obj>5__3))
					{
						<obj>5__3.Disable(((Object)<>4__this).name);
					}
					<obj>5__3 = null;
				}
				<>s__1 = null;
				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 string triggerName;

		public string filter;

		public bool all;

		public bool allInRange;

		public float range = 25f;

		private Disabler[] _toggle = Array.Empty<Disabler>();

		private bool _shouldEnable;

		private void OnEnable()
		{
			_shouldEnable = true;
		}

		private void OnDisable()
		{
			Disabler[] toggle = _toggle;
			foreach (Disabler disabler in toggle)
			{
				if (Object.op_Implicit((Object)(object)disabler))
				{
					((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(disabler.Enable(((Object)this).name));
				}
			}
		}

		private void Update()
		{
			if (_shouldEnable)
			{
				_shouldEnable = false;
				((MonoBehaviour)this).StartCoroutine(DoEnable());
			}
		}

		[IteratorStateMachine(typeof(<DoEnable>d__10))]
		private IEnumerator DoEnable()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoEnable>d__10(0)
			{
				<>4__this = this
			};
		}
	}
	public class ObjectEnabler : MonoBehaviour
	{
		public string objectPath;

		public int index;

		private Enabler _toggle;

		private bool _shouldEnable;

		private bool _setup;

		private void OnEnable()
		{
			_shouldEnable = true;
		}

		private void OnDisable()
		{
			if (Object.op_Implicit((Object)(object)_toggle))
			{
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(_toggle.Disable(((Object)this).name));
			}
		}

		private void Update()
		{
			if (!_setup)
			{
				_setup = true;
				GameObject val = ObjectUtils.FindGameObject(objectPath, index);
				if (Object.op_Implicit((Object)(object)val))
				{
					if (Object.op_Implicit((Object)(object)val.GetComponent<Disabler>()))
					{
						return;
					}
					_toggle = val.GetOrAddComponent<Enabler>();
				}
			}
			if (_shouldEnable)
			{
				_shouldEnable = false;
				DoEnable();
			}
		}

		private void DoEnable()
		{
			if (Object.op_Implicit((Object)(object)_toggle))
			{
				_toggle.Enable(((Object)this).name);
			}
		}
	}
	public class IgnoreDisablers : MonoBehaviour
	{
	}
	public class Disabler : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Enable>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string enableName;

			public Disabler <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)<>4__this))
					{
						return false;
					}
					<>4__this.disablers.Remove(enableName);
					<>4__this.Refresh();
					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 List<string> disablers = new List<string>();

		private bool _enableByDefault;

		private void OnEnable()
		{
			if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<IgnoreDisablers>()))
			{
				((Behaviour)this).enabled = false;
			}
			else if (disablers.Count > 0)
			{
				_enableByDefault = true;
				((Component)this).gameObject.SetActive(false);
			}
		}

		public void Disable(string enableName)
		{
			disablers.Add(enableName);
			Refresh();
		}

		[IteratorStateMachine(typeof(<Enable>d__4))]
		public IEnumerator Enable(string enableName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Enable>d__4(0)
			{
				<>4__this = this,
				enableName = enableName
			};
		}

		private void Refresh()
		{
			if (disablers.Count == 0)
			{
				if (_enableByDefault)
				{
					((Component)this).gameObject.SetActive(true);
				}
			}
			else if (((Component)this).gameObject.activeSelf)
			{
				_enableByDefault = true;
				((Component)this).gameObject.SetActive(false);
			}
		}
	}
	public class Enabler : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Disable>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string enableName;

			public Enabler <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)<>4__this))
					{
						return false;
					}
					<>4__this.enablers.Remove(enableName);
					<>4__this.Refresh();
					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 List<string> enablers = new List<string>();

		private bool _disableByDefault;

		private void OnDisable()
		{
			if (enablers.Count > 0)
			{
				_disableByDefault = true;
				((Component)this).gameObject.SetActive(true);
			}
		}

		public void Enable(string enableName)
		{
			enablers.Add(enableName);
			Refresh();
		}

		[IteratorStateMachine(typeof(<Disable>d__4))]
		public IEnumerator Disable(string enableName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Disable>d__4(0)
			{
				<>4__this = this,
				enableName = enableName
			};
		}

		private void Refresh()
		{
			if (enablers.Count == 0)
			{
				if (_disableByDefault)
				{
					((Component)this).gameObject.SetActive(false);
				}
			}
			else if (!((Component)this).gameObject.activeSelf)
			{
				_disableByDefault = true;
				((Component)this).gameObject.SetActive(true);
			}
		}
	}
	public class RoomClearerConfig : MonoBehaviour
	{
		public bool removeTransitions;

		public bool removeBenches;

		public bool removeBlur;

		public bool removeMusic;

		public bool removeTilemap = true;

		public bool removeOther;
	}
	public class ObjectRemoverConfig : MonoBehaviour
	{
		public string objectPath = "";

		public int index;
	}
	public class ObjectSpinner : PreviewableBehaviour
	{
		public string targetId;

		public float speed;

		private float _startRot;

		private GameObject _target;

		private ObjectAnchor _anchor;

		private bool _setup;

		private bool _previewing;

		private void Update()
		{
			if (!_setup)
			{
				if (!PlacementManager.TryGetValue(targetId, out _target))
				{
					return;
				}
				_setup = true;
				_startRot = Extensions.GetRotation2D(_target.transform);
				_anchor = _target.GetComponent<ObjectAnchor>();
			}
			if (!Object.op_Implicit((Object)(object)_target))
			{
				return;
			}
			if (isAPreview)
			{
				if (Object.op_Implicit((Object)(object)_target.GetComponentInChildren<Prefab>()))
				{
					return;
				}
				if (Settings.Preview.IsPressed)
				{
					_previewing = true;
				}
				else if (_previewing)
				{
					_previewing = false;
					Extensions.SetRotation2D(_target.transform, _startRot);
				}
				if (!_previewing)
				{
					return;
				}
			}
			else if (Object.op_Implicit((Object)(object)_anchor))
			{
				_anchor.rotation += speed * Time.deltaTime;
			}
			_target.transform.Rotate(0f, 0f, speed * Time.deltaTime);
		}
	}
	public class Plasmifier : MonoBehaviour
	{
		public int mode;

		public string id;

		public int heal;

		private bool _plasmified;

		public void Plasmify()
		{
			if (_plasmified)
			{
				return;
			}
			_plasmified = true;
			if (PlacementManager.TryGetValue(id, out var obj))
			{
				ObjectDuplicator component = obj.GetComponent<ObjectDuplicator>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.plasmifier = this;
				}
				else
				{
					Plasmify(obj);
				}
			}
		}

		public void Plasmify(GameObject target)
		{
			HealthManager componentInChildren = target.GetComponentInChildren<HealthManager>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				target.AddComponent<LifebloodState>().healAmount = heal;
			}
		}

		private void Update()
		{
			if (mode == 0 && !_plasmified)
			{
				Plasmify();
			}
		}
	}
	public interface IAnimPlayer
	{
		void Play();

		void Stop();

		string GetClip();
	}
	public class AnimPlayer : MonoBehaviour, IAnimPlayer
	{
		public tk2dSpriteAnimator animator;

		public bool isLocked;

		public tk2dSpriteAnimationClip clip;

		public bool overrideAnimTime;

		public float animTime;

		private float _animTimeRemaining;

		public string GetClip()
		{
			return (!Object.op_Implicit((Object)(object)animator)) ? "" : (animator.currentClip?.name ?? "");
		}

		public static void Init()
		{
			typeof(tk2dSpriteAnimator).Hook("Play", (Action<Action<tk2dSpriteAnimator, tk2dSpriteAnimationClip, float, float>, tk2dSpriteAnimator, tk2dSpriteAnimationClip, float, float>)delegate(Action<tk2dSpriteAnimator, tk2dSpriteAnimationClip, float, float> orig, tk2dSpriteAnimator self, tk2dSpriteAnimationClip clip, float clipStartTime, float overrideFps)
			{
				AnimPlayer component = ((Component)self).GetComponent<AnimPlayer>();
				if (!Object.op_Implicit((Object)(object)component) || !component.isLocked)
				{
					orig(self, clip, clipStartTime, overrideFps);
				}
			}, typeof(tk2dSpriteAnimationClip), typeof(float), typeof(float));
		}

		public void Play()
		{
			_animTimeRemaining = (overrideAnimTime ? animTime : clip.Duration);
			animator.Play(clip);
			isLocked = true;
		}

		public void Stop()
		{
			isLocked = false;
		}

		private void Update()
		{
			if (!(_animTimeRemaining <= 0f))
			{
				_animTimeRemaining -= Time.deltaTime;
				if (_animTimeRemaining <= 0f)
				{
					Stop();
				}
			}
		}
	}
	public class PlayerAnimPlayer : MonoBehaviour, IAnimPlayer
	{
		[CompilerGenerated]
		private sealed class <DoPlay>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerAnimPlayer <>4__this;

			private HeroController <hero>5__1;

			private tk2dSpriteAnimationClip <clip>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<hero>5__1 = null;
				<clip>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<hero>5__1 = HeroController.instance;
					<clip>5__2 = <hero>5__1.animCtrl.GetClip(<>4__this.clipName);
					if (<clip>5__2 == null)
					{
						return false;
					}
					<>4__this._animTimeRemaining = (<>4__this.overrideAnimTime ? <>4__this.animTime : <clip>5__2.Duration);
					<hero>5__1.animCtrl.PlayClipForced(<>4__this.clipName);
					_active = <>4__this;
					if (<>4__this.takeCtrl)
					{
						<>2__current = <hero>5__1.FreeControl();
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					if ((Object)(object)_active != (Object)(object)<>4__this)
					{
						return false;
					}
					<>4__this._tookCtrl = true;
					EditManager.IgnoreControlRelinquished = true;
					<hero>5__1.RelinquishControl();
					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 ScriptBlock Block;

		private static PlayerAnimPlayer _active;

		public string clipName;

		public bool takeCtrl;

		public bool clearXVel = true;

		public bool clearYVel;

		private bool _tookCtrl;

		public bool overrideAnimTime;

		public float animTime;

		private float _animTimeRemaining;

		public string GetClip()
		{
			return HeroController.instance.animCtrl.animator.currentClip?.name ?? "";
		}

		public static void Init()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			new Hook((MethodBase)typeof(HeroAnimationController).GetProperty("controlEnabled").GetGetMethod(), (Delegate)(Func<Func<HeroAnimationController, bool>, HeroAnimationController, bool>)((Func<HeroAnimationController, bool> orig, HeroAnimationController self) => !Object.op_Implicit((Object)(object)_active) && orig(self)));
			typeof(tk2dSpriteAnimator).Hook("Play", (Action<Action<tk2dSpriteAnimator, tk2dSpriteAnimationClip, float, float>, tk2dSpriteAnimator, tk2dSpriteAnimationClip, float, float>)delegate(Action<tk2dSpriteAnimator, tk2dSpriteAnimationClip, float, float> orig, tk2dSpriteAnimator self, tk2dSpriteAnimationClip clip, float clipStartTime, float overrideFps)
			{
				if (!Object.op_Implicit((Object)(object)_active) || !((Object)(object)((Component)self).gameObject == (Object)(object)((Component)HeroController.instance).gameObject))
				{
					orig(self, clip, clipStartTime, overrideFps);
				}
			}, typeof(tk2dSpriteAnimationClip), typeof(float), typeof(float));
		}

		public void Play()
		{
			if (!Object.op_Implicit((Object)(object)_active))
			{
				((MonoBehaviour)this).StartCoroutine(DoPlay());
			}
		}

		[IteratorStateMachine(typeof(<DoPlay>d__13))]
		private IEnumerator DoPlay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoPlay>d__13(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			if (!(_animTimeRemaining <= 0f))
			{
				_animTimeRemaining -= Time.deltaTime;
				if (clearXVel)
				{
					HeroController.instance.rb2d.linearVelocityX = 0f;
				}
				if (clearYVel)
				{
					HeroController.instance.rb2d.linearVelocityY = 0f;
				}
				if (_animTimeRemaining <= 0f)
				{
					Stop();
				}
			}
		}

		public void Stop()
		{
			if ((Object)(object)_active == (Object)(object)this)
			{
				_active = null;
				_animTimeRemaining = 0f;
				if (_tookCtrl)
				{
					_tookCtrl = false;
					EditManager.IgnoreControlRelinquished = false;
					HeroController.instance.RegainControl();
				}
				if (Block != null)
				{
					Block.Event("Stop");
				}
				else
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}
			}
		}

		public void OnDisable()
		{
			Stop();
		}
	}
	public class PlayerDataSetter : MonoBehaviour
	{
		public string dataName;

		public bool value;

		public void SetValue()
		{
			PlayerData.instance.SetBool(dataName, value);
		}

		public void Relay()
		{
			if (PlayerData.instance.GetBool(dataName) == value)
			{
				((Component)this).gameObject.BroadcastEvent("OnCall");
			}
		}
	}
	public class PlayerHook : MonoBehaviour
	{
		public static readonly List<GameObject> PlayerListeners = new List<GameObject>();

		public static readonly List<PlayerBlock.PlayerEvent> PlayerListenerBlocks = new List<PlayerBlock.PlayerEvent>();

		public static void Init()
		{
			typeof(HeroController).Hook("FlipSprite", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				PlayerEvent(self.cState.facingRight ? "FaceRight" : "FaceLeft");
			});
			typeof(HeroController).Hook("HeroJump", (Action<Action<HeroController, bool>, HeroController, bool>)delegate(Action<HeroController, bool> orig, HeroController self, bool checkSprint)
			{
				orig(self, checkSprint);
				PlayerEvent("Jump");
			}, typeof(bool));
			typeof(HeroController).Hook("DoWallJump", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				PlayerEvent("WallJump");
			});
			typeof(HeroController).Hook("DoDoubleJump", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				PlayerEvent("DoubleJump");
			});
			typeof(HeroController).Hook("HeroDash", (Action<Action<HeroController, bool>, HeroController, bool>)delegate(Action<HeroController, bool> orig, HeroController self, bool start)
			{
				orig(self, start);
				PlayerEvent("Dash");
				if (self.dashingDown)
				{
					PlayerEvent("DownDash");
				}
			});
			typeof(HeroController).Hook("BackOnGround", (Action<Action<HeroController, bool>, HeroController, bool>)delegate(Action<HeroController, bool> orig, HeroController self, bool force)
			{
				orig(self, force);
				PlayerEvent("Land");
			});
			typeof(HeroController).Hook("DoHardLanding", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				PlayerEvent("HardLand");
			});
			typeof(HeroController).Hook("Attack", (Action<Action<HeroController, AttackDirection>, HeroController, AttackDirection>)delegate(Action<HeroController, AttackDirection> orig, HeroController self, AttackDirection dir)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Invalid comparison between Unknown and I4
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Invalid comparison between Unknown and I4
				orig(self, dir);
				PlayerEvent("Attack");
				if (1 == 0)
				{
				}
				string triggerName = (((int)dir == 1) ? "UpAttack" : (((int)dir != 2) ? "NormalAttack" : "DownAttack"));
				if (1 == 0)
				{
				}
				PlayerEvent(triggerName);
			});
			typeof(HeroController).Hook("BindCompleted", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				PlayerEvent("OnHeal");
			});
			typeof(HeroController).Hook("BindInterrupted", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				PlayerEvent("OnHealFail");
			});
			typeof(PlayerData).Hook("TakeHealth", (Action<Action<PlayerData, int, bool, bool>, PlayerData, int, bool, bool>)delegate(Action<PlayerData, int, bool, bool> orig, PlayerData self, int amount, bool hasBlue, bool breakMask)
			{
				orig(self, amount, hasBlue, breakMask);
				HpBlock.LastHit = amount;
				PlayerEvent("OnDamage");
			});
			HookUtils.OnHeroAwake = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroAwake, (Action<HeroController>)delegate(HeroController self)
			{
				self.OnDeath += delegate
				{
					PlayerEvent("OnDeath");
				};
				self.OnHazardRespawn += delegate
				{
					PlayerEvent("OnHazardRespawn");
				};
				self.umbrellaFSM.GetState("Inflate").AddAction(delegate
				{
					PlayerEvent("OnInflate");
				}, 0, everyFrame: false);
				self.harpoonDashFSM.GetState("Antic").AddAction(delegate
				{
					PlayerEvent("OnClawline");
				}, 0, everyFrame: false);
				PlayMakerFSM sprintFSM = self.sprintFSM;
				sprintFSM.fsmTemplate = null;
				sprintFSM.GetState("Start Attack").AddAction(delegate
				{
					PlayerEvent("OnDashAttack");
				}, 0, everyFrame: false);
				HeroPerformanceRegion.StartedPerforming += delegate
				{
					PlayerEvent("NeedolinStart");
				};
				HeroPerformanceRegion.StoppedPerforming += delegate
				{
					PlayerEvent("NeedolinStop");
				};
			});
			PlayerDataVariableEvents.OnSetBool += delegate(PlayerData _, string name, bool current)
			{
				if (name == "atBench")
				{
					PlayerEvent(current ? "OnBench" : "OnUnbench");
				}
				return current;
			};
		}

		private static void PlayerEvent(string triggerName)
		{
			GameObject[] array = PlayerListeners.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				array[i]?.BroadcastEvent(triggerName);
			}
			PlayerBlock.PlayerEvent[] array2 = PlayerListenerBlocks.ToArray();
			foreach (PlayerBlock.PlayerEvent playerEvent in array2)
			{
				playerEvent?.Block.Event(triggerName);
				playerEvent?.Block.Event("On" + triggerName);
			}
		}

		private void OnEnable()
		{
			PlayerListeners.Add(((Component)this).gameObject);
		}

		private void OnDisable()
		{
			PlayerListeners.Remove(((Component)this).gameObject);
		}

		public static void KillPlayer(GameObject o)
		{
			HeroController.instance.TakeDamage(o, (CollisionSide)4, 999, (HazardType)2, (DamagePropertyFlags)0);
		}

		public static void DamagePlayer(GameObject o)
		{
			HeroController.instance.TakeDamage(o, (CollisionSide)4, 1, (HazardType)1, (DamagePropertyFlags)0);
		}

		public static void HazardDamagePlayer(GameObject o)
		{
			HeroController.instance.TakeDamage(o, (CollisionSide)4, 1, (HazardType)2, (DamagePropertyFlags)0);
		}

		public static void HealPlayer()
		{
			HeroController.instance.AddHealth(1);
		}

		public static void FullHealPlayer()
		{
			HeroController.instance.RefillHealthToMax();
		}

		public static void GiveSilk()
		{
			HeroController.instance.AddSilk(1, true);
		}

		public static void MaxSilk()
		{
			HeroController.instance.AddSilk(999, true);
		}

		public static void TakeSilk()
		{
			HeroController.instance.TakeSilk(1);
		}

		public static void ClearSilk()
		{
			HeroController.instance.TakeSilk(999);
		}

		public static void DisableVignette()
		{
			((Component)HeroController.instance.vignette).gameObject.SetActive(false);
		}

		public static void EnableVignette()
		{
			((Component)HeroController.instance.vignette).gameObject.SetActive(true);
		}
	}
	public class PreviewableBehaviour : MonoBehaviour
	{
		public bool isAPreview;
	}
	public class RoarEffect : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Roar>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RoarEffect <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					FSMUtility.SendEventToGameObject(<>4__this._roar, "START", false);
					<>2__current = (object)new WaitForSeconds(<>4__this.time);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					FSMUtility.SendEventToGameObject(<>4__this._roar, "END", false);
					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 float time;

		public bool small;

		private GameObject _roar;

		private void Start()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			_roar = Object.Instantiate<GameObject>(((Component)((Component)GameManager.instance.gameCams).gameObject.transform.Find(small ? "Roar Wave Emitter Small" : "Roar Wave Emitter")).gameObject, ((Component)this).transform);
			_roar.transform.position = ((Component)this).transform.position;
		}

		public void DoRoar()
		{
			((MonoBehaviour)this).StartCoroutine(Roar());
		}

		[IteratorStateMachine(typeof(<Roar>d__5))]
		public IEnumerator Roar()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Roar>d__5(0)
			{
				<>4__this = this
			};
		}
	}
	public class SceneBorderRemover : MonoBehaviour
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Func<CameraController, bool>, CameraController, bool> <>9__1_0;

			public static Func<Instruction, bool> <>9__1_2;

			public static Func<Instruction, bool> <>9__1_3;

			public static Func<Instruction, bool> <>9__1_4;

			public static Func<Instruction, bool> <>9__1_5;

			public static Manipulator <>9__1_1;

			internal bool <Init>b__1_0(Func<CameraController, bool> orig, CameraController self)
			{
				return orig(self) || _count > 0 || PrefabManager.InPrefabScene;
			}

			internal void <Init>b__1_1(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[3]
				{
					(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 0f),
					(Instruction _) => true,
					(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 9999f)
				}))
				{
					val.Remove();
					val.Emit(OpCodes.Ldc_R4, -9999f);
					if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
					{
						(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 0f)
					}))
					{
						val.Remove();
						val.Emit(OpCodes.Ldc_R4, -9999f);
					}
				}
			}

			internal bool <Init>b__1_2(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdcR4(instr, 0f);
			}

			internal bool <Init>b__1_3(Instruction _)
			{
				return true;
			}

			internal bool <Init>b__1_4(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdcR4(instr, 9999f);
			}

			internal bool <Init>b__1_5(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdcR4(instr, 0f);
			}
		}

		private static int _count;

		public static void Init()
		{
			//IL_0039: 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_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_0072: Expected O, but got Unknown
			new Hook((MethodBase)typeof(CameraController).GetProperty("AllowExitingSceneBounds").GetGetMethod(), (Delegate)(Func<Func<CameraController, bool>, CameraController, bool>)((Func<CameraController, bool> orig, CameraController self) => orig(self) || _count > 0 || PrefabManager.InPrefabScene));
			MethodInfo? method = typeof(CameraTarget).GetMethod("Update");
			object obj = <>c.<>9__1_1;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Expected O, but got Unknown
					//IL_008c: Unknown result type (might be due to invalid IL or missing references)
					//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val2 = new ILCursor(il);
					if (val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[3]
					{
						(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 0f),
						(Instruction _) => true,
						(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 9999f)
					}))
					{
						val2.Remove();
						val2.Emit(OpCodes.Ldc_R4, -9999f);
						if (val2.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
						{
							(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 0f)
						}))
						{
							val2.Remove();
							val2.Emit(OpCodes.Ldc_R4, -9999f);
						}
					}
				};
				<>c.<>9__1_1 = val;
				obj = (object)val;
			}
			new ILHook((MethodBase)method, (Manipulator)obj);
		}

		private void OnEnable()
		{
			_count++;
		}

		private void OnDisable()
		{
			_count--;
		}
	}
	public class SceneParticleController : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Disable>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					GameCameras.instance.sceneParticles.DisableParticles();
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					GameCameras.instance.sceneParticles.DisableParticles();
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					GameCameras.instance.sceneParticles.DisableParticles();
					return false;
				}
			}

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

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

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(Disable());
		}

		[IteratorStateMachine(typeof(<Disable>d__1))]
		private static IEnumerator Disable()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Disable>d__1(0);
		}
	}
	public class Shielder : MonoBehaviour
	{
		public class ExtraResistance : MonoBehaviour
		{
			public List<AttackTypes> resistances;
		}

		public string id;

		public bool startApplied = true;

		public bool immuneToBeams;

		public bool immuneToCoal;

		public bool immuneToExplosions;

		public bool immuneToHunterWeapon;

		public bool immuneToLava;

		public bool immuneToNailAttacks;

		public bool immuneToSpikes;

		public bool immuneToTraps;

		public bool immuneToWater;

		public List<AttackTypes> extraImmunities = new List<AttackTypes>();

		private bool _shielded;

		public static void Init()
		{
			typeof(HealthManager).Hook("IsImmuneTo", (Func<Func<HealthManager, HitInstance, bool, bool>, HealthManager, HitInstance, bool, bool>)delegate(Func<HealthManager, HitInstance, bool, bool> orig, HealthManager self, HitInstance hit, bool full)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				ExtraResistance component = ((Component)self).GetComponent<ExtraResistance>();
				return (Object.op_Implicit((Object)(object)component) && component.resistances.Contains(hit.AttackType)) || orig(self, hit, full);
			});
		}

		public void Shield()
		{
			if (PlacementManager.TryGetValue(id, out var obj))
			{
				ObjectDuplicator component = obj.GetComponent<ObjectDuplicator>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.shielder = this;
				}
				else
				{
					Shield(obj);
				}
			}
		}

		public void Shield(GameObject target)
		{
			HealthManager componentInChildren = target.GetComponentInChildren<HealthManager>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.immuneToBeams = immuneToBeams;
				componentInChildren.immuneToCoal = immuneToCoal;
				componentInChildren.immuneToExplosions = immuneToExplosions;
				componentInChildren.immuneToHunterWeapon = immuneToHunterWeapon;
				componentInChildren.immuneToLava = immuneToLava;
				componentInChildren.immuneToNailAttacks = immuneToNailAttacks;
				componentInChildren.immuneToSpikes = immuneToSpikes;
				componentInChildren.immuneToTraps = immuneToTraps;
				componentInChildren.immuneToWater = immuneToWater;
				if (!Extensions.IsNullOrEmpty<AttackTypes>((ICollection<AttackTypes>)extraImmunities))
				{
					((Component)componentInChildren).gameObject.GetOrAddComponent<ExtraResistance>().resistances = extraImmunities;
				}
			}
		}

		private void Update()
		{
			if (startApplied && !_shielded)
			{
				_shielded = true;
				Shield();
			}
		}
	}
	public class TextDisplay : NPCControlBase, IDisplayable
	{
		[CompilerGenerated]
		private sealed class <DoDisplay>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public TextDisplay <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = HeroController.instance.FreeControl((HeroController _) => InteractManager.CanInteract);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RelinquishControl();
					DialogueBox.StartConversation(<>4__this.text, (NPCControlBase)(object)<>4__this, false, <>4__this._displayOptions, (Action)delegate
					{
						if (<>4__this.Block != null)
						{
							<>4__this.Block.Event("OnClose");
						}
						else
						{
							((Component)<>4__this).gameObject.BroadcastEvent("OnClose");
						}
						((MonoBehaviour)<>4__this).StartCoroutine(RegainControlDelayed());
					}, (Action)null);
					return false;
				}
			}

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

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

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HeroController.instance.RegainControl();
					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 ScriptBlock Block;

		public string text = "";

		public float offsetY;

		public int verticalAlignment;

		public int horizontalAlignment;

		public bool decorators = true;

		public Color color = Color.white;

		private DisplayOptions _displayOptions;

		public override void Awake()
		{
			((InteractableBase)this).Awake();
			Setup();
		}

		public void Setup()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			int num = verticalAlignment;
			int num2 = horizontalAlignment;
			if (1 == 0)
			{
			}
			TextAlignmentOptions val;
			switch (num)
			{
			case 0:
				switch (num2)
				{
				case 0:
					break;
				case 1:
					goto IL_0067;
				case 2:
					goto IL_006b;
				default:
					goto IL_0089;
				}
				val = (TextAlignmentOptions)0;
				break;
			case 1:
				switch (num2)
				{
				case 0:
					break;
				case 1:
					goto IL_0073;
				case 2:
					goto IL_0077;
				default:
					goto IL_0089;
				}
				val = (TextAlignmentOptions)4;
				break;
			case 2:
				switch (num2)
				{
				case 0:
					break;
				case 1:
					goto IL_007f;
				case 2:
					goto IL_0084;
				default:
					goto IL_0089;
				}
				val = (TextAlignmentOptions)8;
				break;
			default:
				goto IL_0089;
				IL_0084:
				val = (TextAlignmentOptions)10;
				break;
				IL_007f:
				val = (TextAlignmentOptions)9;
				break;
				IL_006b:
				val = (TextAlignmentOptions)2;
				break;
				IL_0077:
				val = (TextAlignmentOptions)6;
				break;
				IL_0073:
				val = (TextAlignmentOptions)5;
				break;
				IL_0067:
				val = (TextAlignmentOptions)1;
				break;
				IL_0089:
				throw new ArgumentOutOfRangeException();
			}
			if (1 == 0)
			{
			}
			TextAlignmentOptions alignment = val;
			_displayOptions = new DisplayOptions
			{
				ShowDecorators = decorators,
				Alignment = alignment,
				OffsetY = offsetY,
				TextColor = color
			};
		}

		public void Display()
		{
			((MonoBehaviour)this).StartCoroutine(DoDisplay());
		}

		[IteratorStateMachine(typeof(<DoDisplay>d__11))]
		private IEnumerator DoDisplay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoDisplay>d__11(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<RegainControlDelayed>d__12))]
		private static IEnumerator RegainControlDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RegainControlDelayed>d__12(0);
		}
	}
	public class Timer : MonoBehaviour
	{
		public float startDelay = 1f;

		public float repeatDelay = 1f;

		public float randDelay;

		public int maxCalls = -1;

		private int _calls;

		private float _time;

		private float _cRepeatDelay;

		private void Update()
		{
			if (startDelay > 0f)
			{
				startDelay -= Time.deltaTime;
				if (startDelay > 0f)
				{
					return;
				}
				_time -= startDelay;
			}
			else
			{
				_time += Time.deltaTime;
				if (_time < _cRepeatDelay)
				{
					return;
				}
				_time -= _cRepeatDelay;
			}
			_calls++;
			_cRepeatDelay = repeatDelay + Random.value * randDelay;
			((Component)this).gameObject.BroadcastEvent("OnCall");
			if (maxCalls != -1 && _calls >= maxCalls)
			{
				_calls = 0;
				((Component)this).gameObject.SetActive(false);
			}
		}
	}
	public class TimeSlower : MonoBehaviour
	{
		public float changeTime;

		public float waitTime;

		public float returnTime;

		public float targetSpeed;

		public bool noPause;

		private static int _timeSlowedCount;

		public static void Init()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			new Hook((MethodBase)typeof(GameManager).GetProperty("TimeSlowed").GetGetMethod(), (Delegate)(Func<Func<GameManager, bool>, GameManager, bool>)((Func<GameManager, bool> orig, GameManager self) => orig(self) && self.timeSlowedCount > _timeSlowedCount));
		}

		public void SlowTime()
		{
			if (!noPause)
			{
				_timeSlowedCount++;
			}
			((MonoBehaviour)GameManager.instance).StartCoroutine(GameManager.instance.FreezeMoment(changeTime, waitTime, returnTime, targetSpeed, (Action)delegate
			{
				if (!noPause)
				{
					_timeSlowedCount--;
				}
				if (Object.op_Implicit((Object)(object)this))
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}
			}));
		}
	}
	public class TitleDisplay : MonoBehaviour, IDisplayable
	{
		public string header;

		public string body;

		public string footer;

		public int type;

		public void Display()
		{
			TitleUtils.DisplayTitle(header, body, footer, type);
		}
	}
	public class TriggerZone : MonoBehaviour
	{
		public static readonly Sprite SquareZone = ResourceUtils.LoadSpriteResource("trigger_zone", (FilterMode)0, default(Vector4), 10f);

		public static readonly Sprite CircleZone = ResourceUtils.LoadSpriteResource("trigger_zone_circle", (FilterMode)0, default(Vector4), 10f);

		public bool block;

		public int mode;

		public int layer;

		public bool usingLayer;

		public bool inside;

		private void OnTriggerEnter2D(Collider2D other)
		{
			switch (mode)
			{
			case 0:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<HeroController>()))
				{
					return;
				}
				break;
			case 1:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<NailSlash>()))
				{
					return;
				}
				break;
			case 2:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<HealthManager>()))
				{
					return;
				}
				break;
			case 3:
			{
				TriggerZone component = ((Component)other).gameObject.GetComponent<TriggerZone>();
				if (!Object.op_Implicit((Object)(object)component) || (component.layer != layer && usingLayer))
				{
					return;
				}
				break;
			}
			case 4:
			{
				MiscFixers.TriggerActivator componentInParent = ((Component)other).gameObject.GetComponentInParent<MiscFixers.TriggerActivator>();
				if (!Object.op_Implicit((Object)(object)componentInParent) || (componentInParent.layer != layer && usingLayer))
				{
					return;
				}
				break;
			}
			}
			EventManager.BroadcastEvent(((Component)this).gameObject, "ZoneEnter");
			inside = true;
		}

		private void OnTriggerExit2D(Collider2D other)
		{
			if (block)
			{
				return;
			}
			switch (mode)
			{
			case 0:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<HeroController>()))
				{
					return;
				}
				break;
			case 1:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<NailSlash>()))
				{
					return;
				}
				break;
			case 2:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<HealthManager>()))
				{
					return;
				}
				break;
			case 3:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<TriggerZone>()))
				{
					return;
				}
				break;
			case 4:
				if (!Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<MiscFixers.TriggerActivator>()))
				{
					return;
				}
				break;
			}
			EventManager.BroadcastEvent(((Component)this).gameObject, "ZoneExit");
			inside = false;
		}

		private void OnEnable()
		{
			block = false;
		}
	}
	public class VignetteDisabler : MonoBehaviour
	{
		public static readonly List<VignetteDisabler> Disablers = new List<VignetteDisabler>();

		private static bool _vignetteOff;

		public static void Init()
		{
			HookUtils.OnHeroUpdate = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroUpdate, (Action<HeroController>)delegate
			{
				if ((PrefabManager.InPrefabScene || Disablers.Count > 0) != _vignetteOff)
				{
					((Component)HeroController.instance.vignette).gameObject.SetActive(_vignetteOff);
					_vignetteOff = !_vignetteOff;
				}
			});
		}

		private void OnEnable()
		{
			Disablers.Add(this);
		}

		private void OnDisable()
		{
			Disablers.Remove(this);
		}
	}
	public class WalkTarget : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Walk>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public WalkTarget <>4__this;

			private HeroController <hero>5__1;

			private Rigidbody2D <body>5__2;

			private Transform <heroTrans>5__3;

			private tk2dSpriteAnimator <animator>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<hero>5__1 = null;
				<body>5__2 = null;
				<heroTrans>5__3 = null;
				<animator>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0252: Unknown result type (might be due to invalid IL or missing references)
				//IL_0267: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._walking)
					{
						return false;
					}
					<hero>5__1 = HeroController.instance;
					<body>5__2 = <hero>5__1.rb2d;
					<heroTrans>5__3 = <hero>5__1.transform;
					<>2__current = <hero>5__1.FreeControl();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)<>4__this))
					{
						return false;
					}
					<hero>5__1.RelinquishControl();
					<hero>5__1.StopAnimationControl();
					<animator>5__4 = ((Component)<hero>5__1).GetComponent<tk2dSpriteAnimator>();
					<animator>5__4.Play(<>4__this.anim);
					EditManager.IgnoreControlRelinquished = true;
					<>4__this._walking = true;
					if (<heroTrans>5__3.position.x > ((Component)<>4__this).transform.position.x)
					{
						<hero>5__1.FaceLeft();
						goto IL_01a1;
					}
					<hero>5__1.FaceRight();
					goto IL_024c;
				case 2:
					<>1__state = -1;
					goto IL_01a1;
				case 3:
					{
						<>1__state = -1;
						goto IL_024c;
					}
					IL_024c:
					if (<heroTrans>5__3.position.x < ((Component)<>4__this).transform.position.x)
					{
						if (!Object.op_Implicit((Object)(object)<>4__this) || !EditManager.IgnoreControlRelinquished)
						{
							return false;
						}
						if (<>4__this._walking)
						{
							<body>5__2.linearVelocityX = <>4__this.speed;
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
					}
					break;
					IL_01a1:
					if (<heroTrans>5__3.position.x > ((Component)<>4__this).transform.position.x)
					{
						if (!Object.op_Implicit((Object)(object)<>4__this) || !EditManager.IgnoreControlRelinquished)
						{
							return false;
						}
						if (<>4__this._walking)
						{
							<body>5__2.linearVelocityX = 0f - <>4__this.speed;
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
					}
					break;
				}
				<>4__this._walking = false;
				EditManager.IgnoreControlRelinquished = false;
				<hero>5__1.RegainControl();
				<hero>5__1.StartAnimationControl();
				((Component)<>4__this).gameObject.BroadcastEvent("OnFinish");
				if (<>4__this.anim == "Sprint")
				{
					<hero>5__1.sprintFSM.SendEvent("SKID END");
				}
				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 float speed;

		public string anim;

		private bool _walking;

		public void StartWalk()
		{
			((MonoBehaviour)this).StartCoroutine(Walk());
		}

		public void StopWalk()
		{
			_walking = false;
		}

		[IteratorStateMachine(typeof(<Walk>d__5))]
		public IEnumerator Walk()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Walk>d__5(0)
			{
				<>4__this = this
			};
		}
	}
}
namespace Architect.Behaviour.Fixers
{
	public static class EnemyFixers
	{
		public class CustomJailer : MonoBehaviour
		{
			public string targetScene = "Slab_03";

			public string targetDoor = "door_slabCaged";

			private void Awake()
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				if (!(targetDoor == "door_slabCaged") || !(targetScene == "Slab_03"))
				{
					PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
					fsm.GetState("Capture Flash").DisableAction(6);
					FsmState state = fsm.GetState("Audio Cut");
					for (int i = 0; i < 4; i++)
					{
						state.DisableAction(i);
					}
					FsmState state2 = fsm.GetState("Start Caged Sequence");
					for (int j = 0; j < 8; j++)
					{
						state2.DisableAction(j);
					}
					((BeginSceneTransition)state2.Actions[8]).sceneName = FsmString.op_Implicit(targetScene);
					((BeginSceneTransition)state2.Actions[8]).entryGateName = FsmString.op_Implicit(targetDoor);
					SceneTeleportMap.AddTransitionGate(targetScene, targetDoor);
				}
			}
		}

		private class LastJudge : MonoBehaviour
		{
			public bool moveLeft;

			public bool moveRight;

			public bool moveUp;

			public bool moveDown;

			private void OnCollisionStay2D(Collision2D other)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: 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_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: 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)
				ContactPoint2D contact = other.GetContact(0);
				Vector2 point = ((ContactPoint2D)(ref contact)).point;
				Vector3 val = ((Component)this).transform.InverseTransformPoint(Vector2.op_Implicit(point));
				moveLeft = false;
				moveRight = false;
				float y = val.y;
				float num = y;
				if (!(num > 0f))
				{
					if (num < 0f && Mathf.Abs(val.y) > Mathf.Abs(val.x))
					{
						moveDown = false;
					}
				}
				else if (Mathf.Abs(val.y) > Mathf.Abs(val.x))
				{
					moveUp = false;
				}
			}
		}

		public class DisableHealthScaling : MonoBehaviour
		{
		}

		public class DisableBossTitle : MonoBehaviour
		{
		}

		public class DisableDeathSlowdown : MonoBehaviour
		{
		}

		public class Karaka : MonoBehaviour
		{
			public bool stayIdle;

			private PlayMakerFSM _fsm;

			private AlertRange _range;

			private FsmState _state;

			private FsmTransition[] _transitions;

			private void Start()
			{
				if (stayIdle)
				{
					_fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
					_range = ((Component)((Component)this).transform.Find("Far Range")).GetComponent<AlertRange>();
					_state = _fsm.GetState("Idle");
					_transitions = _state.transitions;
					_state.transitions = Array.Empty<FsmTransition>();
				}
			}

			private void Update()
			{
				if (Object.op_Implicit((Object)(object)_range) && _range.IsHeroInRange())
				{
					_state.transitions = _transitions;
					_range = null;
					_fsm.SendEvent("FINISHED");
				}
			}
		}

		public class Teleplane : MonoBehaviour
		{
			public float width = 5f;

			public float height = 1f;

			private void Start()
			{
				//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_002e: 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_0046: Expected O, but got Unknown
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				PlayMakerFSM component = ((Component)this).gameObject.GetComponent<PlayMakerFSM>();
				GameObject val = new GameObject(((Object)this).name + " Teleplane");
				val.transform.position = ((Component)this).transform.position;
				val.tag = "Teleplane";
				GameObject val2 = val;
				BoxCollider2D val3 = val2.AddComponent<BoxCollider2D>();
				((Collider2D)val3).isTrigger = true;
				val3.size = new Vector2(width, height);
				FsmState state = component.GetState("Get Teleplane");
				if (state != null)
				{
					((FsmStateAction)(FindClosest)state.actions[0]).name = ((Object)val2).name;
				}
				component.FsmVariables.FindFsmGameObject("Teleplane").Value = val2;
			}
		}

		public class Hornfly : MonoBehaviour
		{
			public Vector2 hopDistance = new Vector2(4f, 4f);

			private void Start()
			{
				PlayMakerFSM component = ((Component)this).GetComponent<PlayMakerFSM>();
				component.FsmVariables.FindFsmFloat("Min X").Value = Extensions.GetPositionX(((Component)this).transform) - hopDistance.x;
				component.FsmVariables.FindFsmFloat("Max X").Value = Extensions.GetPositionX(((Component)this).transform) + hopDistance.y;
			}
		}

		public class Watcher : Wakeable
		{
			public override void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Sleep").AddAction(delegate
				{
					fsm.SendEvent("WAKE");
				}, 0, everyFrame: false);
				fsm.SendEvent("WAKE");
			}
		}

		public class GrandReed : Wakeable
		{
			public override void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Rest").AddAction(delegate
				{
					fsm.SendEvent("WAKE");
				}, -1, everyFrame: false);
				fsm.SendEvent("WAKE");
			}
		}

		private class Freshfly : MonoBehaviour
		{
			public Vector3 pos;

			private void OnEnable()
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				PlayMakerFSM component = ((Component)this).GetComponent<PlayMakerFSM>();
				if (!((Behaviour)component).enabled)
				{
					((Component)this).transform.position = pos;
					((Behaviour)component).enabled = true;
				}
			}
		}

		public class AknidMother : SoundMaker
		{
			public bool active;

			private static readonly AudioClip[] Clips = (AudioClip[])(object)new AudioClip[4];

			private static AudioClip _sporeClip;

			private static AudioClip _yelpClip;

			public static void InitSounds()
			{
				ResourceUtils.LoadClipResource("AknidMother.hit_1", delegate(AudioClip clip)
				{
					Clips[0] = clip;
				});
				ResourceUtils.LoadClipResource("AknidMother.hit_2", delegate(AudioClip clip)
				{
					Clips[1] = clip;
				});
				ResourceUtils.LoadClipResource("AknidMother.hit_3", delegate(AudioClip clip)
				{
					Clips[2] = clip;
				});
				ResourceUtils.LoadClipResource("AknidMother.hit_4", delegate(AudioClip clip)
				{
					Clips[3] = clip;
				});
				ResourceUtils.LoadClipResource("AknidMother.spore", delegate(AudioClip clip)
				{
					_sporeClip = clip;
				});
				ResourceUtils.LoadClipResource("AknidMother.yelp", delegate(AudioClip clip)
				{
					_yelpClip = clip;
				});
			}

			private void Start()
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				if (active)
				{
					((Component)this).GetComponent<EnemyHitEffectsRegular>().ReceivedHitEffect += (ReceivedHitEffectDelegate)delegate
					{
						PlaySound(Clips[Random.RandomRangeInt(0, 4)], 0.5f, 1.2f);
					};
					PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
					fsm.GetState("Sing End").transitions[0].toFsmState = fsm.GetState("Recover");
					fsm.GetState("Startle").AddAction(delegate
					{
						PlaySound(_yelpClip, 0.65f, 1.2f);
					}, 0, everyFrame: false);
					fsm.GetState("Shake Start").AddAction(delegate
					{
						PlaySound(_sporeClip, 0.65f, 1.2f);
					}, 0, everyFrame: false);
				}
			}
		}

		public class Shardillard : Wakeable
		{
			private bool _shouldWake = true;

			public override void DoUnwake()
			{
				_shouldWake = false;
			}

			public override void DoWake()
			{
				_shouldWake = false;
				((Component)this).GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
				((Component)this).GetComponent<DamageHero>().damageDealt = 1;
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Init").AddAction(delegate
				{
					fsm.SetState("Recover");
				}, 3, everyFrame: false);
				fsm.GetState("Rest").AddAction(delegate
				{
					fsm.SendEvent("ALERT");
				}, -1, everyFrame: false);
				fsm.SendEvent("ALERT");
			}

			private void Update()
			{
				if (_shouldWake)
				{
					DoWake();
				}
			}
		}

		public class PatrollerFix : MonoBehaviour
		{
			public float xOffset;

			public float yOffset;

			private void Awake()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_0080: 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_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Expected O, but got Unknown
				PlayMakerFSM component = ((Component)this).GetComponent<PlayMakerFSM>();
				FsmGameObject val = component.FsmVariables.FindFsmGameObject("Start Point") ?? component.FsmVariables.FindFsmGameObject("Patrol Start Point");
				GameObject val2 = new GameObject(((Object)this).name + " Start Point");
				val2.transform.position = ((Component)this).transform.position;
				val.Value = val2;
				FsmGameObject obj = component.FsmVariables.FindFsmGameObject("Patrol Point");
				GameObject val3 = new GameObject(((Object)this).name + " Patrol Point");
				val3.transform.position = ((Component)this).transform.position + new Vector3(xOffset, yOffset);
				obj.Value = val3;
			}
		}

		public abstract class Wakeable : MonoBehaviour
		{
			public virtual void DoWake()
			{
			}

			public virtual void DoUnwake()
			{
			}
		}

		public class Mossgrub : Wakeable
		{
			public override void DoWake()
			{
				FSMUtility.LocateMyFSM(((Component)this).gameObject, "Noise Reaction").SendEvent("WAKE");
			}
		}

		public class CoralFurm : Wakeable
		{
			private PlayMakerFSM _fsm;

			private void Prepare()
			{
				if (!Object.op_Implicit((Object)(object)_fsm))
				{
					_fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				}
			}

			public override void DoUnwake()
			{
				Prepare();
				_fsm.GetState("Init").AddAction(delegate
				{
					_fsm.SendEvent("HIDING");
				}, 0, everyFrame: false);
				_fsm.GetState("Hiding").DisableAction(4);
				((Component)this).GetComponent<tk2dSpriteAnimator>().Play("Rest");
			}

			public override void DoWake()
			{
				Prepare();
				_fsm.SendEvent("WAKE");
			}
		}

		public class Boran : Wakeable
		{
			public override void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Rest").AddAction(delegate
				{
					fsm.SendEvent("WAKE");
				}, 0, everyFrame: false);
				fsm.SendEvent("WAKE");
			}
		}

		public class SpearSkarr : Wakeable
		{
			public override void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Init").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				fsm.SendEvent("WAKE");
			}
		}

		public class Judge : Wakeable
		{
			public override void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Init").AddAction(delegate
				{
					fsm.SendEvent("PATROL");
				}, 2, everyFrame: false);
				fsm.SendEvent("WAKE");
			}
		}

		public class Driznit : Wakeable
		{
			public override void DoWake()
			{
				FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control").SendEvent("ALERT");
			}
		}

		public class Flintbeetle : Wakeable
		{
			public override void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Wall").AddAction(delegate
				{
					fsm.SendEvent("WAKE");
				}, -1, everyFrame: false);
				fsm.SendEvent("WAKE");
			}
		}

		public class FakePersistentMarker : MonoBehaviour
		{
		}

		public class FourthChorus : MonoBehaviour
		{
			public GameObject plats;

			public GameObject parent;

			public GameObject head;

			public bool threaded;

			public bool doPlats;

			private bool _done;

			private void Update()
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				if (threaded)
				{
					threaded = false;
					tk2dSprite[] componentsInChildren = parent.GetComponentsInChildren<tk2dSprite>(true);
					foreach (tk2dSprite val in componentsInChildren)
					{
						if ((Object)(object)((Component)val).gameObject != (Object)(object)((Component)this).gameObject)
						{
							((tk2dBaseSprite)val).color = Color.black;
						}
					}
					SpriteRenderer[] componentsInChildren2 = parent.GetComponentsInChildren<SpriteRenderer>(true);
					foreach (SpriteRenderer val2 in componentsInChildren2)
					{
						if ((Object)(object)((Component)val2).gameObject != (Object)(object)((Component)this).gameObject)
						{
							val2.color = Color.black;
						}
					}
				}
				if (!_done)
				{
					_done = true;
					PersistentBoolItem componentInChildren = ((Component)this).GetComponentInChildren<PersistentBoolItem>(true);
					if (Object.op_Implicit((Object)(object)componentInChildren) && ((PersistentItemData<bool>)(object)componentInChildren.itemData).Value)
					{
						((Component)this).gameObject.SetActive(false);
					}
				}
			}

			private void Start()
			{
				if (!doPlats)
				{
					plats.SetActive(false);
				}
			}
		}

		public class DeathMarker : MonoBehaviour
		{
			public float time;
		}

		public class Squirm : MonoBehaviour
		{
			public CircleCollider2D hideRange;

			public CircleCollider2D musicRange;
		}

		private class TweenFixer : MonoBehaviour
		{
		}

		public class Lace : Wakeable
		{
			public override void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Dormant").AddAction(delegate
				{
					fsm.SendEvent("ENTER");
				}, -1, everyFrame: false);
				fsm.SendEvent("ENTER");
			}
		}

		public class Unravelled : Wakeable
		{
			public PlayMakerFSM fsm;

			public override void DoWake()
			{
				fsm.GetState("Dormant").AddAction(delegate
				{
					fsm.SendEvent("WAKE");
				}, -1, everyFrame: false);
				fsm.SendEvent("WAKE");
			}
		}

		private static GameObject _bouldersPrefab;

		private static GameObject _freshflyCagePrefab;

		private static GameObject _robotParticles;

		private static GameObject _pinProjectiles;

		private static GameObject _loosePins;

		private static GameObject _blasts;

		private static GameObject _shieldTrail;

		private static GameObject _flares;

		private static GameObject _floor;

		private static GameObject _bursts;

		private static GameObject _tflares;

		private static GameObject _tfloor;

		private static GameObject _tbursts;

		private static GameObject _squirmSingArea;

		private static GameObject _squirmArea;

		private static GameObject _corpseProjectiles;

		private static GameObject _attackSpears;

		private static readonly List<string> Spears = new List<string>(7) { "Long Spear", "Air Spear", "Uppercut Spear", "Roar Spikes", "Cross Spears", "Cross Followup Spears", "Shoot Spikes" };

		private static readonly Dictionary<string, GameObject> SpearObjects = new Dictionary<string, GameObject>();

		private static GameObject _grindSpikesL;

		private static GameObject _grindSpikesR;

		private static GameObject _lavaPlats;

		private static GameObject _lavaRocks;

		private static GameObject _splinterSpikes;

		private static readonly int EnemiesLayer = LayerMask.NameToLayer("Enemies");

		private static readonly int HeroDetector = LayerMask.NameToLayer("Hero Detector");

		private static readonly PhysicsMaterial2D PinMaterial = new PhysicsMaterial2D
		{
			friction = 1f
		};

		private static readonly int TerrainMask = LayerMask.GetMask(new string[1] { "Terrain" });

		public static void Init()
		{
			HookUtils.OnFsmAwake = (Action<PlayMakerFSM>)Delegate.Combine(HookUtils.OnFsmAwake, (Action<PlayMakerFSM>)delegate(PlayMakerFSM fsm)
			{
				if (fsm.FsmName == "Control" && ((Object)((Component)fsm).gameObject).name == "Last Judge Charge Bomb(Clone)")
				{
					fsm.GetState("Antic").DisableAction(2);
				}
			});
			typeof(HealthManager).Hook("ApplyDamageScaling", (Func<Func<HealthManager, HitInstance, HitInstance>, HealthManager, HitInstance, HitInstance>)((Func<HealthManager, HitInstance, HitInstance> orig, HealthManager self, HitInstance hit) => (Object.op_Implicit((Object)(object)((Component)self).GetComponentInParent<DisableHealthScaling>()) || CustomNeedle.Needles.ContainsKey(ArchitectData.Instance.CustomNeedle)) ? hit : orig(self, hit)));
			typeof(DisplayBossTitle).Hook("OnEnter", (Action<Action<DisplayBossTitle>, DisplayBossTitle>)delegate(Action<DisplayBossTitle> orig, DisplayBossTitle self)
			{
				if (Object.op_Implicit((Object)(object)((Component)((FsmStateAction)self).fsmComponent).GetComponentInParent<DisableBossTitle>()))
				{
					self.bossTitle.value = "";
				}
				orig(self);
			});
			typeof(SendMessage).Hook("OnEnter", (Action<Action<SendMessage>, SendMessage>)delegate(Action<SendMessage> orig, SendMessage self)
			{
				if (self.functionCall.FunctionName.Contains("FreezeMoment") && Object.op_Implicit((Object)(object)((Component)((FsmStateAction)self).fsmComponent).GetComponent<DisableDeathSlowdown>()))
				{
					((FsmStateAction)self).Finish();
				}
				else
				{
					orig(self);
				}
			});
			typeof(CreateObject).Hook("OnEnter", (Action<Action<CreateObject>, CreateObject>)delegate(Action<CreateObject> orig, CreateObject self)
			{
				GameObject value = self.gameObject.value;
				if (Object.op_Implicit((Object)(object)value) && Object.op_Implicit((Object)(object)value.GetComponent<FreezeMomentOnEnable>()) && Object.op_Implicit((Object)(object)((Component)((FsmStateAction)self).fsmComponent).GetComponent<DisableDeathSlowdown>()))
				{
					((FsmStateAction)self).Finish();
				}
				else
				{
					orig(self);
				}
			});
			PreloadManager.RegisterPreload(new BasicPreload("Bonetown_boss", "Boss Scene/Boulders Battle", delegate(GameObject o)
			{
				_bouldersPrefab = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Slab_16b", "Broodmother Scene Control/Broodmother Scene/Battle Scene Broodmother/Spawner Flies", delegate(GameObject o)
			{
				_freshflyCagePrefab = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Cog_Dancers_boss", "Dancer Control/Death Chunks 1", delegate(GameObject o)
			{
				_robotParticles = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Slab_10b", "Boss Scene/Pin Projectiles", delegate(GameObject o)
			{
				_pinProjectiles = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Slab_10b", "Boss Scene/Loose Pins", delegate(GameObject o)
			{
				_loosePins = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Slab_10b", "Boss Scene/Blasts", delegate(GameObject o)
			{
				_blasts = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Shellwood_22", "Boss Scene/Pt Shield Trail", delegate(GameObject o)
			{
				_shieldTrail = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Library_13", "Grand Stage Scene/Boss Scene Trobbio/Flare Glitter", delegate(GameObject o)
			{
				_flares = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Library_13", "Grand Stage Scene/Boss Scene Trobbio/Floor Tiles", delegate(GameObject o)
			{
				_floor = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Library_13", "Grand Stage Scene/Boss Scene Trobbio/Trapdoor Bursts", delegate(GameObject o)
			{
				_bursts = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Coral_36", "Judge Children Sing Trigger", delegate(GameObject o)
			{
				_squirmSingArea = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Coral_36", "Judge Children Trigger", delegate(GameObject o)
			{
				_squirmArea = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Ward_02_boss", "Boss Scene/Corpse Projectiles", delegate(GameObject o)
			{
				_corpseProjectiles = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Ward_02_boss", "Boss Scene/Attack Spears", delegate(GameObject o)
			{
				_attackSpears = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Library_13", "Grand Stage Scene/Boss Scene TormentedTrobbio/Flare Glitter", delegate(GameObject o)
			{
				_tflares = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Library_13", "Grand Stage Scene/Boss Scene TormentedTrobbio/Floor Tiles", delegate(GameObject o)
			{
				_tfloor = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Library_13", "Grand Stage Scene/Boss Scene TormentedTrobbio/Trapdoor Bursts", delegate(GameObject o)
			{
				_tbursts = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Shellwood_18", "Boss Scene Parent/Boss Scene/Spikes", delegate(GameObject o)
			{
				_splinterSpikes = o;
			}));
			foreach (string spear in Spears)
			{
				PreloadManager.RegisterPreload(new BasicPreload("Memory_Coral_Tower", "Boss Scene/" + spear, delegate(GameObject o)
				{
					SpearObjects[spear] = o;
				}));
			}
			PreloadManager.RegisterPreload(new BasicPreload("Memory_Ant_Queen", "Boss Scene/Grind Spikes R", delegate(GameObject o)
			{
				o.RemoveComponentsInChildren<CheckOutOfBoundsX>();
				_grindSpikesR = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Memory_Ant_Queen", "Boss Scene/Grind Spikes L", delegate(GameObject o)
			{
				o.RemoveComponentsInChildren<CheckOutOfBoundsX>();
				_grindSpikesL = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Bone_East_08", "Boss Scene/Lava Plats", delegate(GameObject o)
			{
				_lavaPlats = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Bone_East_08", "Boss Scene/Lava Rocks", delegate(GameObject o)
			{
				KeepActive(o);
				_lavaRocks = o;
			}));
			typeof(iTween).Hook("Launch", (Action<Action<GameObject, Hashtable>, GameObject, Hashtable>)delegate(Action<GameObject, Hashtable> orig, GameObject obj, Hashtable table)
			{
				if (Object.op_Implicit((Object)(object)obj.GetComponent<TweenFixer>()))
				{
					iTween2d.Launch(obj, table);
				}
				else
				{
					orig(obj, table);
				}
			});
			AknidMother.InitSounds();
		}

		public static void ApplyGravity(GameObject obj)
		{
			obj.GetOrAddComponent<Rigidbody2D>().gravityScale = 1f;
		}

		public static void FixAknid(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			FSMUtility.LocateMyFSM(obj, "Control").GetState("Get Next Point").actions[0].enabled = true;
		}

		public static void KeepActive(GameObject obj)
		{
			obj.RemoveComponentsInChildren<DeactivateIfPlayerdataTrue>();
			obj.RemoveComponentsInChildren<DeactivateIfPlayerdataFalse>();
			obj.RemoveComponentsInChildren<DeactivateIfPlayerdataFalseDelayed>();
			obj.RemoveComponentsInChildren<TestGameObjectActivator>();
			obj.RemoveComponentsInChildren<PlayerDataTestResponse>();
		}

		public static void KeepActiveRemoveConstrainPos(GameObject obj)
		{
			KeepActive(obj);
			RemoveConstrainPosition(obj);
		}

		public static void FixJailer(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Is Cursed Dead?").AddAction(delegate
			{
				fsm.SendEvent("FALSE");
			}, 0, everyFrame: false);
			fsm.GetState("Is Here?").AddAction(delegate
			{
				fsm.SendEvent("FALSE");
			}, 0, everyFrame: false);
			fsm.GetState("Is Cursed?").AddAction(delegate
			{
				fsm.SendEvent("FALSE");
			}, 0, everyFrame: false);
		}

		public static void FixLastJudge(GameObject obj)
		{
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Expected O, but got Unknown
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Expected O, but got Unknown
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f2: Unknown result type (might be due to invalid IL or missing references)
			RemoveConstrainPosition(obj);
			LastJudge lj = obj.AddComponent<LastJudge>();
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SetState("Intro Roar Antic");
			}, -1, everyFrame: false);
			fsm.GetState("First Idle").AddAction(delegate
			{
				fsm.SendEvent("ENCOUNTERED");
			}, 0, everyFrame: false);
			FsmFloat groundY = fsm.FsmVariables.FindFsmFloat("Ground Y");
			FsmFloat jumpY = fsm.FsmVariables.FindFsmFloat("Jump Y");
			FsmFloat xTarget = fsm.FsmVariables.FindFsmFloat("X Target");
			FsmFloat xDist = fsm.FsmVariables.FindFsmFloat("X Distance");
			FsmFloat censerSlamSelfY = fsm.FsmVariables.FindFsmFloat("Censer Slam Self Y");
			FsmFloat censerBotY = fsm.FsmVariables.FindFsmFloat("Censer Bot Y");
			FsmFloat censerTopY = fsm.FsmVariables.FindFsmFloat("Censer Top Y");
			FsmFloat stompY = fsm.FsmVariables.FindFsmFloat("Stomp Y");
			fsm.GetState("Throw Rise").AddAction(AdjustCenserGroundPos, 11, everyFrame: false);
			fsm.GetState("Censer Slam").AddAction(AdjustCenserSlam, 0, everyFrame: false);
			float x = obj.transform.position.x;
			fsm.FsmVariables.FindFsmFloat("Centre X").Value = x;
			FsmState state = fsm.GetState("Charge Check");
			state.DisableAction(1);
			state.DisableAction(2);
			FsmState state2 = fsm.GetState("Spin Check");
			state2.DisableAction(2);
			state2.DisableAction(3);
			FsmState state3 = fsm.GetState("Throw Check");
			state3.DisableAction(1);
			state3.DisableAction(2);
			FsmState state4 = fsm.GetState("Rage Roar 1");
			state4.DisableAction(3);
			state4.DisableAction(4);
			FsmState state5 = fsm.GetState("Flame Roar 1");
			state5.DisableAction(3);
			state5.DisableAction(4);
			fsm.GetState("Throw Antic").AddAction(delegate
			{
				obj.BroadcastEvent("CenserThrow");
			}, 0, everyFrame: false);
			fsm.GetState("Censer Slam").AddAction(delegate
			{
				obj.BroadcastEvent("CenserSlam");
			}, 0, everyFrame: false);
			fsm.GetState("Spin Antic").AddAction(delegate
			{
				obj.BroadcastEvent("Swing");
			}, 0, everyFrame: false);
			fsm.GetState("Stomp Regular").AddAction(delegate
			{
				obj.BroadcastEvent("Slam");
			}, 0, everyFrame: false);
			fsm.GetState("Stomp Flames").AddAction(delegate
			{
				obj.BroadcastEvent("FireSlam");
			}, 0, everyFrame: false);
			fsm.GetState("Charge").AddAction(delegate
			{
				obj.BroadcastEvent("FlameCharge");
			}, 0, everyFrame: false);
			obj.GetComponent<HealthManager>().IsInvincible = false;
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(component.GetInstantiatedCorpse((AttackTypes)0), "Control");
			fsm2.GetState("Death Start").DisableAction(3);
			fsm2.GetState("Break 4").AddAction(delegate
			{
				fsm.SendEvent("CANCEL");
			}, 5, everyFrame: false);
			CheckYPosition fall = (CheckYPosition)fsm2.GetState("Fall").Actions[2];
			SetPosition land = (SetPosition)fsm2.GetState("Land").Actions[0];
			FsmState state6 = fsm.GetState("Intro Roar");
			((StartRoarEmitter)state6.actions[3]).stunHero = FsmBool.op_Implicit(false);
			state6.AddAction(MakeDynamicWithGravity, 0, everyFrame: false);
			fsm.GetState("Charge Antic 1").AddAction(MakeDynamicWithGravity, 0, everyFrame: false);
			fsm.GetState("Dash Antic").AddAction(MakeDynamicWithGravity, 0, everyFrame: false);
			fsm.GetState("Evade Antic").AddAction(MakeDynamicWithGravity, 0, everyFrame: false);
			state2.AddAction(MakeDynamicWithGravity, 0, everyFrame: false);
			state3.AddAction(MakeDynamicWithGravity, 0, everyFrame: false);
			FsmState state7 = fsm.GetState("Idle");
			state7.AddAction(AdjustGroundPosForSelf, 0, everyFrame: false);
			state7.AddAction(MakeDynamicWithGravity, 0, everyFrame: false);
			FsmState state8 = fsm.GetState("Range Check");
			state8.AddAction(AdjustGroundPosForSelf, 0, everyFrame: false);
			state8.AddAction(MakeKinematic, 0, everyFrame: false);
			FsmState state9 = fsm.GetState("Stun Start");
			state9.AddAction(AdjustGroundPosForGround, 0, everyFrame: false);
			fsm.GetState("Stomp JumpAntic").AddAction(MakeDynamic, 0, everyFrame: false);
			fsm.GetState("OJump Antic").AddAction(MakeDynamic, 0, everyFrame: false);
			fsm.GetState("Jump Antic").AddAction(MakeDynamic, 0, everyFrame: false);
			FsmState state10 = fsm.GetState("Jump Rise");
			FsmState state11 = fsm.GetState("Ojump Rise");
			FsmState state12 = fsm.GetState("Stomp Rise and Antic");
			FsmState state13 = fsm.GetState("Stomp Down");
			FsmState state14 = fsm.GetState("Jump Fall");
			FsmState state15 = fsm.GetState("Land");
			FsmFloat tweenX = fsm.FsmVariables.FindFsmFloat("Tween X");
			FsmFloat tweenY = fsm.FsmVariables.FindFsmFloat("Tween Y");
			state10.DisableAction(10);
			state11.DisableAction(14);
			state12.DisableAction(13);
			state13.DisableAction(0);
			state14.DisableAction(0);
			state14.DisableAction(6);
			state15.DisableAction(2);
			((SetVelocityByScale)state13.actions[3]).everyFrame = true;
			state13.AddAction(AdjustGroundPosForGround, 4, everyFrame: true);
			state10.AddAction(delegate
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				rb2d.MovePosition(new Vector2((lj.moveRight || lj.moveLeft) ? tweenX.Value : Extensions.GetPositionX(obj.transform), lj.moveUp ? tweenY.Value : Extensions.GetPositionY(obj.transform)));
				if (!lj.moveLeft && !lj.moveRight)
				{
					xTarget.Value = Extensions.GetPositionX(obj.transform);
					xDist.Value = 0f;
				}
				if (!lj.moveUp)
				{
					jumpY.Value = Extensions.GetPositionY(obj.transform);
				}
			}, 10, everyFrame: true);
			state10.AddAction(delegate
			{
				lj.moveUp = true;
				lj.moveLeft = xTarget.Value < Extensions.GetPositionX(obj.transform);
				lj.moveRight = !lj.moveLeft;
			}, 8, everyFrame: false);
			state10.AddAction(AdjustGroundPosForTarget, 8, everyFrame: false);
			state11.AddAction(delegate
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				rb2d.MovePosition(new Vector2((lj.moveRight || lj.moveLeft) ? tweenX.Value : Extensions.GetPositionX(obj.transform), lj.moveUp ? tweenY.Value : Extensions.GetPositionY(obj.transform)));
				if (!lj.moveLeft && !lj.moveRight)
				{
					xTarget.Value = Extensions.GetPositionX(obj.transform);
					xDist.Value = 0f;
				}
				if (!lj.moveUp)
				{
					jumpY.Value = Extensions.GetPositionY(obj.transform);
				}
			}, 14, everyFrame: true);
			state11.AddAction(delegate
			{
				lj.moveUp = true;
				lj.moveLeft = xTarget.Value < Extensions.GetPositionX(obj.transform);
				lj.moveRight = !lj.moveLeft;
			}, 12, everyFrame: false);
			state11.AddAction(AdjustGroundPosForTarget, 12, everyFrame: false);
			state12.AddAction(delegate
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				rb2d.MovePosition(new Vector2((lj.moveRight || lj.moveLeft) ? tweenX.Value : Extensions.GetPositionX(obj.transform), lj.moveUp ? tweenY.Value : Extensions.GetPositionY(obj.transform)));
			}, 13, everyFrame: true);
			state12.AddAction(delegate
			{
				lj.moveUp = true;
				lj.moveLeft = xTarget.Value < Extensions.GetPositionX(obj.transform);
				lj.moveRight = !lj.moveLeft;
			}, 11, everyFrame: false);
			state14.AddAction(delegate
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				rb2d.MovePosition(new Vector2((lj.moveRight || lj.moveLeft) ? tweenX.Value : Extensions.GetPositionX(obj.transform), lj.moveDown ? tweenY.Value : Extensions.GetPositionY(obj.transform)));
			}, 6, everyFrame: true);
			state14.AddAction(delegate
			{
				lj.moveDown = true;
			}, 4, everyFrame: false);
			AdjustGroundPosForSelf();
			void AdjustCenserGroundPos()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				float positionY2 = Extensions.GetPositionY(obj.transform);
				Vector2 val2 = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val2, new Vector2(xTarget.Value + xDist.Value, positionY2 + 4.5f), true))
				{
					float num4 = val2.y - 0.94f;
					censerTopY.Value = Mathf.Clamp(num4, positionY2 - 2.5f, positionY2) + 10.82f;
					censerBotY.Value = num4;
					if (positionY2 > num4)
					{
						float num5 = Mathf.Sqrt(Mathf.Abs(positionY2 - num4)) / 4f;
						if (xDist.Value < 0f)
						{
							num5 = 0f - num5;
						}
						FsmFloat obj2 = xTarget;
						obj2.Value += num5;
						FsmFloat obj3 = xDist;
						obj3.Value += num5;
					}
				}
			}
			void AdjustCenserSlam()
			{
				float positionY = Extensions.GetPositionY(obj.transform);
				censerSlamSelfY.value = censerBotY.Value - positionY;
			}
			void AdjustGroundPos(Vector2 source, bool cannotJumpDown)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val, source, true))
				{
					float num = val.y + 2.7f;
					groundY.Value = num;
					float num2 = num;
					if (cannotJumpDown)
					{
						num2 = Mathf.Max(source.y - 3f, num2);
					}
					jumpY.Value = num2 + 5.78f;
					stompY.Value = num + 4.58f;
					fall.compareTo = FsmFloat.op_Implicit(num - 1f);
					land.y = FsmFloat.op_Implicit(num - 1f);
				}
			}
			void AdjustGroundPosForGround()
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				AdjustGroundPos(Vector2.op_Implicit(obj.transform.position), cannotJumpDown: false);
			}
			void AdjustGroundPosForSelf()
			{
				float num3 = Extensions.GetPositionY(obj.transform) + 1.1057f;
				groundY.Value = num3;
				jumpY.Value = num3 + 5.78f;
				stompY.Value = num3 + 4.58f;
				fall.compareTo = FsmFloat.op_Implicit(num3 - 1f);
				land.y = FsmFloat.op_Implicit(num3 - 1f);
			}
			void AdjustGroundPosForTarget()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				AdjustGroundPos(new Vector2(xTarget.value + xDist.value, Extensions.GetPositionY(obj.transform)), cannotJumpDown: true);
			}
			void MakeDynamic()
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				rb2d.bodyType = (RigidbodyType2D)0;
				rb2d.gravityScale = 0f;
				rb2d.linearVelocity = Vector2.zero;
			}
			void MakeDynamicWithGravity()
			{
				rb2d.bodyType = (RigidbodyType2D)0;
				rb2d.gravityScale = 3f;
			}
			void MakeKinematic()
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				rb2d.bodyType = (RigidbodyType2D)1;
				rb2d.gravityScale = 0f;
				rb2d.linearVelocity = Vector2.zero;
			}
		}

		public static void RemoveConstrainPosition(GameObject obj)
		{
			obj.RemoveComponentsInChildren<ConstrainPosition>();
		}

		public static void FixBloatroachPreload(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			ParticleSystemRenderer component = ((Component)obj.transform.Find("Pt Spit Void").GetChild(0)).GetComponent<ParticleSystemRenderer>();
			((Renderer)component).material = ((Renderer)component).material;
		}

		public static void FixBloatroach(GameObject obj)
		{
			PlayMakerFSM val2 = FSMUtility.LocateMyFSM(obj, "Control");
			FsmBool val = val2.FsmVariables.FindFsmBool("In Attack Range");
			val2.GetState("Idle").AddAction(delegate
			{
				//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)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: 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_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				Vector3 position = HeroController.instance.transform.position;
				Vector3 position2 = obj.transform.position;
				val.Value = Mathf.Abs(position.x - position2.x) < 15f && Mathf.Abs(position.y - position2.y) < 2f;
			}, 4, everyFrame: true);
		}

		public static void FixDuctsucker(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Return Type").AddAction(delegate
			{
				fsm.SendEvent("UNALERT");
			}, 0, everyFrame: false);
		}

		public static void FixFlintFlyer(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Behaviour");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 6, everyFrame: false);
		}

		public static void FixSpearSpawned(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control") ?? FSMUtility.LocateMyFSM(obj, "Behaviour");
			fsm.GetState("Spear Spawn Pause").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 3, everyFrame: false);
		}

		public static void FixYumama(GameObject obj)
		{
			FSMUtility.LocateMyFSM(obj, "Control").FsmVariables.FindFsmBool("Idle Patrol").value = true;
		}

		public static void FixKaraka(GameObject obj)
		{
			obj.AddComponent<Karaka>();
			FixSpearSpawned(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 4, everyFrame: false);
		}

		public static void ClearRotation(GameObject obj)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			obj.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
		}

		public static void FixDriller(GameObject obj)
		{
			FixSpearSpawned(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("SPEAR SPAWNER");
			}, 2, everyFrame: false);
			fsm.GetState("Memory Arena Clamp").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
		}

		public static void FixSkrill(GameObject obj)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Vector3 sourcePos = obj.transform.position;
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Behaviour");
			fsm.GetState("Hidden").AddAction(delegate
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = HeroController.instance.transform.position - sourcePos;
				if (!(((Vector3)(ref val)).sqrMagnitude < 1024f))
				{
					fsm.SendEvent("HERO GONE");
				}
			}, 0, everyFrame: true);
		}

		public static void FixForumEnemy(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 4, everyFrame: false);
		}

		public static void FixMinister(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Fly In Ready").AddAction(delegate
			{
				fsm.SetState("Activate");
			}, 0, everyFrame: false);
			bool started = false;
			fsm.GetState("Chase").AddAction(delegate
			{
				if (!started)
				{
					started = true;
					fsm.SendEvent("UNALERT");
				}
			}, 0, everyFrame: false);
			FsmBool patrol = fsm.FsmVariables.FindFsmBool("In Patrol Range");
			fsm.GetState("Unalert Patrol").AddAction(delegate
			{
				patrol.value = true;
			}, 5, everyFrame: false);
		}

		public static void FixMaestro(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 42, everyFrame: false);
			bool started = false;
			fsm.GetState("Fly").AddAction(delegate
			{
				if (!started)
				{
					started = true;
					fsm.SendEvent("UNALERT");
				}
			}, 0, everyFrame: false);
			FsmGameObject[] flies = (FsmGameObject[])(object)new FsmGameObject[3]
			{
				fsm.FsmVariables.FindFsmGameObject("Fly 1"),
				fsm.FsmVariables.FindFsmGameObject("Fly 2"),
				fsm.FsmVariables.FindFsmGameObject("Fly 3")
			};
			fsm.GetState("Fly").AddAction(FixCogflies, 0, everyFrame: false);
			fsm.GetState("Summon").AddAction(FixCogflies, 3, everyFrame: false);
			void FixCogflies()
			{
				FsmGameObject[] array = flies;
				foreach (FsmGameObject val in array)
				{
					GameObject value = val.value;
					if (!Object.op_Implicit((Object)(object)value))
					{
						break;
					}
					BlackThreadState component = obj.GetComponent<BlackThreadState>();
					bool flag = Object.op_Implicit((Object)(object)component) && component.CheckIsBlackThreaded();
					BlackThreadState component2 = value.GetComponent<BlackThreadState>();
					if (component2.CheckIsBlackThreaded() == flag)
					{
						break;
					}
					component2.SetBlackThreadAmount(0f);
					component2.isBlackThreadWorld = flag;
					component2.ResetThreaded();
				}
			}
		}

		public static void FixSurgeon(GameObject obj)
		{
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Idle");
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			obj.AddComponent<Teleplane>();
		}

		public static void FixDregwheel(GameObject obj)
		{
			//IL_0053: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("SPAWN M");
			}, 0, everyFrame: false);
			((SetFloatValue)fsm.GetState("Spawn Mid").actions[0]).floatValue.value = obj.transform.position.x;
			fsm.FsmVariables.FindFsmFloat("Ground Y").value = obj.transform.position.y;
			fsm.GetState("Spawn Roll Clamp")?.DisableAction(2);
			fsm.FsmVariables.FindFsmBool("No Respawn").value = true;
			obj.GetComponent<HealthManager>().hasSpecialDeath = false;
			FsmState state = fsm.GetState("Spawn Roll");
			state.DisableAction(6);
			state.DisableAction(9);
			state.DisableAction(10);
			FsmState state2 = fsm.GetState("Spawn Antic");
			((SetPosition)state2.actions[1]).y = FsmFloat.op_Implicit(obj.transform.position.y);
			state2.DisableAction(4);
		}

		public static void FixDregHusk(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.FsmVariables.FindFsmBool("Spawner").value = false;
			obj.GetComponent<HealthManager>().invincible = false;
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
		}

		public static void FixMoorwing(GameObject obj)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, -1, everyFrame: false);
			FsmState state = fsm.GetState("Zoom Down");
			state.DisableAction(2);
			state.DisableAction(3);
			state.AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, -1, everyFrame: false);
			((StartRoarEmitter)fsm.GetState("Quick Roar").actions[3]).stunHero = FsmBool.op_Implicit(false);
			fsm.GetState("Do Roar?").AddAction(delegate
			{
				fsm.SendEvent("SKIP");
			}, 0, everyFrame: false);
			fsm.GetState("Quick Roar").DisableAction(5);
			FsmState state2 = fsm.GetState("Quick Roar End");
			state2.DisableAction(1);
			state2.DisableAction(2);
			state2.DisableAction(3);
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.setPlayerDataBool = "";
			component.PreInstantiate();
			PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(component.GetInstantiatedCorpse((AttackTypes)1), "Death");
			fsm2.GetState("Stagger").DisableAction(2);
			fsm2.GetState("Blow").DisableAction(1);
			fsm2.GetState("Splash").DisableAction(0);
		}

		public static void FixGroal(GameObject obj)
		{
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			HealthManager component = obj.GetComponent<HealthManager>();
			component.invincible = false;
			FsmState state = fsm.GetState("Fly Idle");
			state.transitions = state.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			FsmState state2 = fsm.GetState("Attack Choice");
			state2.transitions = state2.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, 0, everyFrame: false);
			fsm.GetState("Fake Battle End").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Entry Antic").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Entry Dive").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 4, everyFrame: false);
			((StartRoarEmitter)fsm.GetState("Entry Roar").actions[1]).stunHero = FsmBool.op_Implicit(false);
			fsm.FsmVariables.FindFsmFloat("X Centre").value = obj.transform.position.x;
			fsm.FsmVariables.FindFsmFloat("X Min").value = obj.transform.position.x - 13.75f;
			fsm.FsmVariables.FindFsmFloat("X Max").value = obj.transform.position.x + 13.75f;
			float num = HeroController.instance.FindGroundPointY(obj.transform.position.x, obj.transform.position.y, true);
			fsm.FsmVariables.FindFsmFloat("Y Underwater ").value = num - 4.56f;
			fsm.FsmVariables.FindFsmFloat("Splash In Y").value = num - 3.2f;
			fsm.FsmVariables.FindFsmFloat("Pt WaterSplash Y").value = num - 3.2f;
			fsm.GetState("Fight Start").DisableAction(0);
			fsm.GetState("Trap").AddAction(delegate
			{
				obj.BroadcastEvent("TrySpikeTrap");
			}, 1, everyFrame: false);
			FsmState state3 = fsm.GetState("Summon");
			state3.AddAction(delegate
			{
				obj.BroadcastEvent("TrySpikeTrap");
			}, 3, everyFrame: false);
			state3.AddAction(delegate
			{
				obj.BroadcastEvent("TrySummon");
			}, 1, everyFrame: false);
			fsm.GetState("Dive Up Antic").DisableAction(4);
			fsm.GetState("End Battle").AddAction(delegate
			{
				Object.Destroy((Object)(object)obj);
			}, -1, everyFrame: false);
		}

		public static void FixStilkin(GameObject obj)
		{
			//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)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			RemoveConstrainPosition(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SetState("Set Evade Hops");
			}, 6, everyFrame: false);
			fsm.GetState("Hidden G").AddAction(delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = obj.transform.position - HeroController.instance.transform.position;
				if (((Vector3)(ref val)).magnitude < 12f)
				{
					fsm.SendEvent("AMBUSH");
				}
			}, 0, everyFrame: true);
			fsm.GetState("Positioning Check").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Hidden Underwater").DisableAction(0);
			Vector2 pos = default(Vector2);
			if (!HeroController.instance.TryFindGroundPoint(ref pos, Vector2.op_Implicit(obj.transform.position), true))
			{
				pos = Vector2.op_Implicit(obj.transform.position);
			}
			fsm.GetState("Get Node").AddAction(delegate
			{
				//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)
				obj.transform.position = Vector2.op_Implicit(pos);
			}, 0, everyFrame: false);
			fsm.GetState("Dig Out G 1").AddAction(delegate
			{
				obj.BroadcastEvent("OnAmbush");
			}, 0, everyFrame: false);
		}

		public static void FixStilkinTrapper(GameObject obj)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			RemoveConstrainPosition(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				obj.GetComponent<tk2dSpriteAnimator>().Play("Hop");
				fsm.SetState("Flutter Start");
			}, 2, everyFrame: false);
			fsm.GetState("Hidden G").AddAction(delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = obj.transform.position - HeroController.instance.transform.position;
				if (((Vector3)(ref val)).magnitude < 12f)
				{
					fsm.SendEvent("AMBUSH");
				}
			}, 0, everyFrame: true);
			fsm.GetState("Node Check").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Dig Out G 1");
			((Tk2dPlayAnimationWithEvents)state.actions[2]).clipName = FsmString.op_Implicit("Hop");
			state.AddAction((FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.4f),
				finishEvent = FsmEvent.Finished
			});
			FsmState state2 = fsm.GetState("Dig Out G 2");
			state2.DisableAction(0);
			state2.AddAction(delegate
			{
				fsm.SetState("Water Exit Q");
			}, -1, everyFrame: false);
			fsm.GetState("Water Exit Q").DisableAction(6);
			fsm.GetState("Hide Underwater").DisableAction(0);
			fsm.GetState("Water Pos").DisableAction(1);
			Vector2 pos = default(Vector2);
			if (!HeroController.instance.TryFindGroundPoint(ref pos, Vector2.op_Implicit(obj.transform.position), true))
			{
				pos = Vector2.op_Implicit(obj.transform.position);
			}
			fsm.GetState("Get Node").AddAction(delegate
			{
				//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)
				obj.transform.position = Vector2.op_Implicit(pos);
			}, 0, everyFrame: false);
			fsm.GetState("Dig Out G 1").AddAction(delegate
			{
				obj.BroadcastEvent("OnAmbush");
			}, 0, everyFrame: false);
		}

		public static void FixLastClawPreload(GameObject obj)
		{
			Extensions.SetPositionZ(obj.transform, 0.006f);
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Fly");
		}

		public static void FixLastClaw(GameObject obj)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			obj.layer = 11;
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = fsm.GetState("Guard");
			state.DisableAction(0);
			state.AddAction(delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = obj.transform.position - HeroController.instance.transform.position;
				if (((Vector3)(ref val)).magnitude < 12f)
				{
					fsm.SetState("Roar");
				}
			}, -1, everyFrame: true);
			state.AddAction((FsmStateAction)new IdleBuzz
			{
				gameObject = new FsmOwnerDefault
				{
					gameObject = FsmGameObject.op_Implicit(obj)
				},
				roamingRange = FsmFloat.op_Implicit(1f),
				waitMax = FsmFloat.op_Implicit(1f),
				waitMin = FsmFloat.op_Implicit(0.5f),
				accelerationMax = FsmFloat.op_Implicit(20f),
				speedMax = FsmFloat.op_Implicit(5f)
			});
			float firstMoveTime = 0f;
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			FsmState state2 = fsm.GetState("Charge");
			state2.AddAction(delegate
			{
				firstMoveTime = Time.time;
			}, -1, everyFrame: false);
			state2.AddAction(delegate
			{
				if (!(Time.time - firstMoveTime < 0.1f) && Mathf.Abs(rb2d.linearVelocityX) < 0.05f)
				{
					fsm.SendEvent("END");
				}
			}, -1, everyFrame: true);
			FsmState state3 = fsm.GetState("Dthrust");
			state3.AddAction(delegate
			{
				firstMoveTime = Time.time;
			}, -1, everyFrame: false);
			state3.AddAction(delegate
			{
				if (!(Time.time - firstMoveTime < 0.1f) && Mathf.Abs(rb2d.linearVelocityY) < 0.05f)
				{
					fsm.SendEvent("LAND");
				}
			}, -1, everyFrame: true);
			fsm.FsmVariables.FindFsmFloat("Max Height").value = Extensions.GetPositionY(obj.transform) + 15f;
		}

		public static void ScaleLastClaw(GameObject obj, float scale)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = obj.transform;
			transform.localScale *= scale;
			if (!(scale < 1f))
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
				FsmFloat distance = ((RayCast2dV2)fsm.GetState("Charge").actions[4]).distance;
				distance.value *= scale;
				FsmFloat distance2 = ((RayCast2dV2)fsm.GetState("Dthrust").actions[8]).distance;
				distance2.value *= scale;
			}
		}

		public static void FixMossMother(GameObject obj)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmVariables fsmVariables = fsm.FsmVariables;
			FsmFloat centreX = fsmVariables.FindFsmFloat("Centre X");
			FsmFloat leftX = fsmVariables.FindFsmFloat("Left X");
			FsmFloat rightX = fsmVariables.FindFsmFloat("Right X");
			FsmFloat swoopY = fsmVariables.FindFsmFloat("Swoop Height");
			FsmFloat maxY = fsmVariables.FindFsmFloat("Max Height");
			fsm.GetState("Init").AddAction(delegate
			{
				//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)
				Realign(Vector2.op_Implicit(obj.transform.position));
			}, 0, everyFrame: false);
			((Renderer)obj.GetComponent<MeshRenderer>()).enabled = true;
			((Component)obj.transform.GetChild(0)).gameObject.SetActive(false);
			fsm.GetState("Dormant").AddAction(delegate
			{
				if (!obj.GetComponent<HealthManager>().isDead)
				{
					fsm.SetState("Roar");
				}
			}, 0, everyFrame: false);
			((StartRoarEmitter)fsm.GetState("Roar").actions[9]).stunHero = FsmBool.op_Implicit(false);
			fsm.GetState("Idle").AddAction(delegate
			{
				//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)
				Realign(Vector2.op_Implicit(HeroController.instance.transform.position));
			}, 0, everyFrame: false);
			fsm.GetState("Slam").AddAction(delegate
			{
				obj.BroadcastEvent("Slam");
			}, 0, everyFrame: false);
			fsm.GetState("Slam RePos").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Swoop");
			state.DisableAction(1);
			state.DisableAction(2);
			state.DisableAction(3);
			FsmState state2 = fsm.GetState("Roar End");
			state2.DisableAction(3);
			state2.DisableAction(4);
			fsm.GetState("End").DisableAction(4);
			void Realign(Vector2 source)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				centreX.value = source.x;
				leftX.value = source.x - 10.5f;
				rightX.value = source.x + 10.5f;
				swoopY.value = source.y;
				maxY.value = source.y + 6f;
			}
		}

		public static void FixSkullTyrant(GameObject obj)
		{
			//IL_00b2: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Behaviour");
			fsm.GetState("State Check").AddAction(delegate
			{
				fsm.SendEvent("INVADING");
			}, 0, everyFrame: false);
			fsm.GetState("Check Respawn Pos").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Standard Respawn").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Invading Pause");
			state.DisableAction(6);
			state.DisableAction(7);
			state.AddAction((FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.1f),
				finishEvent = FsmEvent.Finished
			});
			FsmState state2 = fsm.GetState("Invading Idle");
			state2.DisableAction(0);
			state2.DisableAction(1);
			state2.AddAction(delegate
			{
				if (!obj.GetComponent<HealthManager>().isDead)
				{
					fsm.SendEvent("WAKE");
				}
			}, 10, everyFrame: false);
			fsm.GetState("Invading").AddAction(delegate
			{
				fsm.SendEvent("ROAR");
			}, 0, everyFrame: false);
			fsm.GetState("Invading Idle 2").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("ReWake Roar").AddAction(fsm.GetState("Wake Roar").actions[2], 3);
			FsmState state3 = fsm.GetState("Roar End");
			state3.DisableAction(1);
			state3.DisableAction(2);
			fsm.GetState("Kill Pilby? 2").DisableAction(1);
			GameObject boulders = Object.Instantiate<GameObject>(_bouldersPrefab);
			boulders.SetActive(true);
			fsm.FsmVariables.FindFsmGameObject("Boulders Battle").value = boulders;
			FsmState state4 = fsm.GetState("Boulder Choice");
			state4.AddAction(delegate
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				obj.BroadcastEvent("Stomp");
				Extensions.SetPositionX(boulders.transform, obj.transform.position.x);
			}, 0, everyFrame: false);
		}

		public static void FixSavageBeastfly(GameObject obj)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			HealthManager component = obj.GetComponent<HealthManager>();
			component.IsInvincible = false;
			component.hasSpecialDeath = false;
			tk2dSpriteAnimator component2 = obj.GetComponent<tk2dSpriteAnimator>();
			component2.Play(component2.DefaultClip);
			((StartRoarEmitter)fsm.GetState("Intro Roar").actions[1]).stunHero = FsmBool.op_Implicit(false);
			FsmBool entered = fsm.FsmVariables.FindFsmBool("Hero Entered");
			FsmBool slam = fsm.FsmVariables.FindFsmBool("Final Slam");
			fsm.GetState("Choice").AddAction(delegate
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				if (!entered.value)
				{
					Vector3 val2 = obj.transform.position - HeroController.instance.transform.position;
					if (((Vector3)(ref val2)).magnitude < 12f)
					{
						fsm.SendEvent("INTRO");
					}
				}
			}, 0, everyFrame: false);
			fsm.GetState("Intro Antic").AddAction(delegate
			{
				entered.value = true;
				slam.value = true;
			}, 0, everyFrame: false);
			fsm.GetState("Roar Pos").DisableAction(4);
			fsm.GetState("Summon Type").AddAction(delegate
			{
				obj.BroadcastEvent("TrySummon");
			}, 0, everyFrame: false);
			GameObject val = new GameObject(((Object)obj).name + " Stomp Y");
			fsm.FsmVariables.FindFsmGameObject("Stomp Y").value = val;
			val.transform.position = obj.transform.position;
			fsm.FsmVariables.FindFsmFloat("High Y Pos").value = Extensions.GetPositionY(obj.transform);
			FsmState state = fsm.GetState("Intro Recover");
			state.DisableAction(4);
			state.DisableAction(5);
			fsm.GetState("Stomp").DisableAction(9);
			FsmState state2 = fsm.GetState("Floor Slam");
			state2.DisableAction(0);
			state2.AddAction(delegate
			{
				obj.BroadcastEvent("FloorSlam");
			}, 0, everyFrame: false);
			fsm.GetState("Wall Slam").AddAction(delegate
			{
				obj.BroadcastEvent("WallSlam");
			}, 0, everyFrame: false);
		}

		public static void FixElderPilgrim(GameObject obj)
		{
			KeepActive(obj);
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Idle");
		}

		public static void FixBonegravePilgrim(GameObject obj)
		{
			PlayMakerFSM fsm = obj.GetComponent<PlayMakerFSM>();
			fsm.fsmTemplate = null;
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
		}

		public static void FixWatcher(GameObject obj)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			obj.AddComponent<Watcher>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Start State").AddAction(delegate
			{
				fsm.SendEvent("SLEEP");
			}, 0, everyFrame: false);
			fsm.GetState("Away").DisableAction(2);
			fsm.GetState("Die").DisableAction(0);
			((StartRoarEmitter)fsm.GetState("Wake Roar 2").actions[4]).stunHero = FsmBool.op_Implicit(false);
			fsm.FsmVariables.FindFsmFloat("Dig Min X").Value = Extensions.GetPositionX(obj.transform) - 12.5f;
			fsm.FsmVariables.FindFsmFloat("Dig Max X").Value = Extensions.GetPositionX(obj.transform) + 12.5f;
			fsm.FsmVariables.FindFsmFloat("Start Dig X Max").Value = 99999f;
			fsm.FsmVariables.FindFsmFloat("Cliff Y").value = float.MaxValue;
			GameObject val = new GameObject("Battle Range");
			val.transform.parent = obj.transform;
			val.transform.localPosition = Vector3.zero;
			val.layer = HeroDetector;
			GameObject val2 = val;
			BoxCollider2D val3 = val2.AddComponent<BoxCollider2D>();
			((Collider2D)val3).isTrigger = true;
			val3.size = new Vector2(50f, 16f);
			AlertRange value = val2.AddComponent<AlertRange>();
			fsm.FsmVariables.FindFsmObject("Battle Range").Value = (Object)(object)value;
			fsm.GetState("Uppercut Launch").DisableAction(4);
			FsmState state = fsm.GetState("Idle");
			state.transitions = state.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			FsmState state2 = fsm.GetState("Range Check");
			state2.transitions = state2.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			((Behaviour)FSMUtility.LocateMyFSM(obj, "Battle Music")).enabled = false;
		}

		public static void FixZango(GameObject obj)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").DisableAction(3);
			fsm.GetState("Extract Kill").AddAction(delegate
			{
				obj.BroadcastEvent("OnDeath");
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Rest");
			state.DisableAction(1);
			state.AddAction(delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = obj.transform.position - HeroController.instance.transform.position;
				if (((Vector3)(ref val)).magnitude < 12f)
				{
					fsm.SendEvent("WAKE");
				}
			}, -1, everyFrame: true);
			((StartRoarEmitter)fsm.GetState("Roar").actions[2]).stunHero = FsmBool.op_Implicit(false);
		}

		public static void FixKarmelitaPreload(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Roar");
			Extensions.SetPositionZ(obj.transform, 0.006f);
		}

		public static void FixKarmelita(GameObject obj)
		{
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			GameObject spikesL = Object.Instantiate<GameObject>(_grindSpikesL);
			((Object)spikesL).name = ((Object)obj).name + " Spikes L";
			GameObject spikesR = Object.Instantiate<GameObject>(_grindSpikesR);
			((Object)spikesR).name = ((Object)obj).name + " Spikes R";
			fsm.FsmVariables.FindFsmGameObject("Grind Spikes L").Value = spikesL;
			fsm.FsmVariables.FindFsmGameObject("Grind Spikes R").Value = spikesR;
			BlackThreader.BlackThreadData blackThreadData = obj.AddComponent<BlackThreader.BlackThreadData>();
			blackThreadData.SingCheck = () => fsm.ActiveStateName.Contains("Movement");
			blackThreadData.OnBlackThread = delegate
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				DamageHero[] componentsInChildren = spikesL.GetComponentsInChildren<DamageHero>(true);
				foreach (DamageHero val2 in componentsInChildren)
				{
					val2.damagePropertyFlags = (DamagePropertyFlags)(val2.damagePropertyFlags | 8);
				}
				DamageHero[] componentsInChildren2 = spikesR.GetComponentsInChildren<DamageHero>(true);
				foreach (DamageHero val3 in componentsInChildren2)
				{
					val3.damagePropertyFlags = (DamagePropertyFlags)(val3.damagePropertyFlags | 8);
				}
			};
			fsm.fsm.startState = "Roar Antic";
			HealthManager hm = obj.GetComponent<HealthManager>();
			fsm.GetState("Roar Antic").AddAction(delegate
			{
				fsm.FsmVariables.FindFsmInt("P2 HP").Value = (int)((float)hm.hp * 0.65f);
				fsm.FsmVariables.FindFsmInt("P3 HP").Value = (int)((float)hm.hp * 0.35f);
			}, 0, everyFrame: false);
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			((StartRoarEmitter)fsm.GetState("Roar").actions[0]).stunHero = FsmBool.op_Implicit(false);
			fsm.GetState("Battle Start").DisableAction(0);
			FsmState state = fsm.GetState("Attack Choice");
			state.transitions = state.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			fsm.GetState("Spin Aim").DisableAction(5);
			FsmGameObject obj2 = fsm.FsmVariables.FindFsmGameObject("Arena Centre");
			GameObject val = new GameObject(((Object)obj).name + " Arena Centre");
			val.transform.position = obj.transform.position;
			obj2.Value = val;
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			GameObject corpse = component.GetInstantiatedCorpse((AttackTypes)1);
			RemoveConstrainPosition(corpse);
			PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(corpse, "Death");
			FsmState state2 = fsm2.GetState("Stagger");
			state2.DisableAction(8);
			state2.DisableAction(9);
			state2.transitions[0].toState = "Steam";
			state2.transitions[0].toFsmState = fsm2.GetState("Steam");
			FsmState state3 = fsm2.GetState("Blow");
			state3.DisableAction(2);
			state3.transitions = Array.Empty<FsmTransition>();
			state3.AddAction(delegate
			{
				Object.Destroy((Object)(object)corpse);
			}, -1, everyFrame: false);
			FsmFloat landY = fsm.FsmVariables.FindFsmFloat("Land Y");
			FsmFloat otherLandY = ((CheckYPosition)fsm.GetState("Wall Dive").actions[6]).compareTo;
			FsmState state4 = fsm.GetState("Spear Slam");
			FsmFloat spearSlamY = ((SetPosition)state4.actions[7]).y;
			FsmState state5 = fsm.GetState("Air Sickles");
			FsmState state6 = fsm.GetState("Air Sickles 2");
			FsmFloat airSickles1Y = ((SetPosition2d)state5.actions[1]).y;
			FsmFloat airSickles2Y = ((SetPosition2d)state6.actions[1]).y;
			state5.AddAction(FixSickles, 0, everyFrame: false);
			state6.AddAction(FixSickles, 0, everyFrame: false);
			fsm.GetState("Spin Attack").AddAction(AdjustPositions, 0, everyFrame: true);
			fsm.GetState("Throw Fall").AddAction(AdjustPositions, 0, everyFrame: true);
			fsm.GetState("Wall Dive").AddAction(AdjustPositions, 0, everyFrame: true);
			FsmState state7 = fsm.GetState("Stun Air");
			float time = 0f;
			state7.AddAction(delegate
			{
				time = Time.time;
			}, -1, everyFrame: false);
			state7.AddAction(delegate
			{
				if (Time.time - time > 5f)
				{
					fsm.SendEvent("LAND");
				}
			}, -1, everyFrame: true);
			FsmGameObject spearSet = fsm.FsmVariables.FindFsmGameObject("Spear Set");
			state4.AddAction(delegate
			{
				spearSet.Value.RemoveComponentsInChildren<CheckOutOfBoundsX>();
			}, 7, everyFrame: false);
			fsm.GetState("Dash Grind").AddAction(FixSpikes, 0, everyFrame: false);
			FsmState state8 = fsm.GetState("Restart Singing");
			FsmState state9 = fsm.GetState("Stun Start");
			state8.DisableAction(0);
			state9.DisableAction(13);
			state9.AddAction(delegate
			{
				obj.BroadcastEvent("OnStun");
			}, 0, everyFrame: false);
			state8.AddAction(delegate
			{
				obj.BroadcastEvent("OnRecover");
			}, 0, everyFrame: false);
			AdjustPositions();
			void AdjustPositions()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				float num = HeroController.instance.FindGroundPointY(obj.transform.position.x, obj.transform.position.y + 0.5f, true) + 1.57f;
				landY.Value = num;
				otherLandY.Value = num + 0.27f;
				spearSlamY.Value = num - 2.23f;
			}
			void FixSickles()
			{
				airSickles1Y.Value = Extensions.GetPositionY(obj.transform) - 3.92f;
				airSickles2Y.Value = Extensions.GetPositionY(obj.transform) - 3.92f;
			}
			void FixSpikes()
			{
				Extensions.SetPositionY(spikesL.transform, landY.Value - 21.13f);
				Extensions.SetPositionY(spikesR.transform, landY.Value - 21.13f);
				Extensions.SetPositionX(spikesL.transform, Extensions.GetPositionX(obj.transform) - 71f);
				Extensions.SetPositionX(spikesR.transform, Extensions.GetPositionX(obj.transform) + 71f);
			}
		}

		public static void FixCraggler(GameObject obj)
		{
			KeepActive(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("WAKE");
			}, -1, everyFrame: false);
		}

		public static void FixFlyin(GameObject obj)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Fly");
			((tk2dBaseSprite)obj.GetComponent<tk2dSprite>()).color = Color.white;
			((Renderer)obj.GetComponent<MeshRenderer>()).enabled = true;
			FSMUtility.LocateMyFSM(obj, "Control").FsmVariables.FindFsmBool("Battler").value = false;
		}

		public static void FixClawmaiden(GameObject obj)
		{
			obj.AddComponent<Teleplane>();
		}

		public static void FixVaultborn(GameObject obj)
		{
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Idle");
		}

		public static void FixBrushflit(GameObject obj)
		{
			obj.GetComponent<FlockFlyer>().activeProbability = 1f;
		}

		public static void ScaleBrushflit(GameObject obj, float scale)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			FlockFlyer component = obj.GetComponent<FlockFlyer>();
			component.minScale *= scale;
			component.maxScale *= scale;
		}

		public static void FixSummonedSaviour(GameObject obj)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				((Collider2D)obj.GetComponent<BoxCollider2D>()).isTrigger = false;
				fsm.SendEvent("WAKE");
			}, -1, everyFrame: false);
			fsm.GetState("Action").DisableAction(2);
			((StartRoarEmitter)fsm.GetState("Roar").actions[2]).stunHero = FsmBool.op_Implicit(false);
			FsmState state = fsm.GetState("Dash Dir");
			state.DisableAction(1);
			state.DisableAction(2);
			fsm.GetState("Dash To").DisableAction(0);
			RandomFloat rf = (RandomFloat)fsm.GetState("Set Dash Pos").actions[1];
			fsm.GetState("Set Dash Pos").AddAction(delegate
			{
				rf.min = FsmFloat.op_Implicit(Extensions.GetPositionY(HeroController.instance.transform) - 2.5f);
				rf.max = FsmFloat.op_Implicit(Extensions.GetPositionY(HeroController.instance.transform) + 2.5f);
			}, 0, everyFrame: false);
		}

		public static void FixBroodmother(GameObject obj)
		{
			//IL_0075: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			RemoveConstrainPosition(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			GameObject val = Object.Instantiate<GameObject>(_freshflyCagePrefab);
			val.SetActive(true);
			fsm.FsmVariables.FindFsmGameObject("Spawner Flies").value = val;
			((StartRoarEmitter)fsm.GetState("Roar").actions[7]).stunHero = FsmBool.op_Implicit(false);
			fsm.GetState("Dormant").AddAction((FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.1f),
				finishEvent = FsmEvent.GetFsmEvent("BATTLE START")
			});
			fsm.GetState("Entry Antic").AddAction(delegate
			{
				HealthManager component = obj.GetComponent<HealthManager>();
				if (component.isDead)
				{
					((Behaviour)fsm).enabled = false;
				}
				else
				{
					component.enemyDeathEffects.GetInstantiatedCorpse((AttackTypes)1).RemoveComponent<ConstrainPosition>();
					fsm.SendEvent("FINISHED");
				}
			}, 0, everyFrame: false);
			fsm.GetState("Burst In").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
		}

		public static void FixFreshfly(GameObject obj)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Bouncer Control");
			fsm.fsmTemplate = null;
			fsm.GetState("Start Pause").AddAction(delegate
			{
				fsm.SetState("Left or Right?");
			}, 11, everyFrame: false);
			obj.GetComponent<HealthManager>().hasSpecialDeath = false;
			obj.AddComponent<Freshfly>().pos = obj.transform.position;
		}

		public static void FixKarakGor(GameObject obj)
		{
			FSMUtility.LocateMyFSM(obj, "Control").FsmVariables.FindFsmBool("Spear Spawner").Value = false;
			obj.GetComponent<tk2dSpriteAnimator>().defaultClipId = 8;
		}

		public static void FixAlita(GameObject obj)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.FsmVariables.FindFsmBool("Spear Spawner").Value = false;
			float positionY = Extensions.GetPositionY(obj.transform);
			val.FsmVariables.FindFsmFloat("Tele Air Y Max").Value = positionY + 8f;
			val.FsmVariables.FindFsmFloat("Tele Air Y Min").Value = positionY + 2f;
			val.FsmVariables.FindFsmFloat("Tele Ground Y").Value = positionY;
			val.FsmVariables.FindFsmFloat("Tele X Max").Value = Extensions.GetPositionX(obj.transform) + 11f;
			val.FsmVariables.FindFsmFloat("Tele X Min").Value = Extensions.GetPositionX(obj.transform) - 11f;
			val.FsmVariables.FindFsmGameObject("Aiming Cursor").Value = new GameObject(((Object)obj).name + " Aim Cursor");
		}

		public static void FixSecondSentinelBoss(GameObject obj)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			GameObject corpse = component.GetInstantiatedCorpse((AttackTypes)1);
			FsmState state = FSMUtility.LocateMyFSM(corpse, "Death").GetState("Blow");
			state.transitions = Array.Empty<FsmTransition>();
			state.AddAction(delegate
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				GameObject val3 = Object.Instantiate<GameObject>(_robotParticles, corpse.transform.position, corpse.transform.rotation);
				((Component)val3.transform.Find("Chunks")).gameObject.SetActive(false);
				val3.SetActive(true);
				corpse.SetActive(false);
			}, -1, everyFrame: false);
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.fsmTemplate = null;
			PlayerDataBoolTest val2 = (PlayerDataBoolTest)val.GetState("Init").actions[7];
			val2.isFalse = val2.isTrue;
			val.FsmVariables.FindFsmBool("Hornet Dead").Value = false;
			val.GetState("Dash Slash 3").DisableAction(2);
			((Component)obj.transform.Find("Catch Markers")).gameObject.RemoveComponent<ConstrainPosition>();
			Object.Destroy((Object)(object)FSMUtility.LocateMyFSM(obj, "Save Hero"));
		}

		public static void FixLugoli(GameObject obj)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, -1, everyFrame: false);
			FsmState state = fsm.GetState("Entry Antic");
			state.DisableAction(2);
			((Wait)state.actions[3]).time = FsmFloat.op_Implicit(0.01f);
			fsm.GetState("Stun Start").DisableAction(3);
			FsmState state2 = fsm.GetState("Check L");
			state2.DisableAction(0);
			state2.DisableAction(1);
			state2.DisableAction(4);
			fsm.GetState("Check M").DisableAction(2);
			fsm.GetState("Check R").DisableAction(2);
			fsm.GetState("Dive End").DisableAction(3);
			fsm.GetState("Swipe 5").AddAction(delegate
			{
				obj.BroadcastEvent("OnLadleSlam");
			}, 0, everyFrame: false);
			fsm.GetState("Stomp Land").AddAction(delegate
			{
				obj.BroadcastEvent("OnStompLand");
			}, 0, everyFrame: false);
			fsm.GetState("Butt Land").AddAction(delegate
			{
				obj.BroadcastEvent("OnButtLand");
			}, 0, everyFrame: false);
			FsmState state3 = fsm.GetState("Pick Point");
			state3.DisableAction(0);
			state3.DisableAction(1);
			state3.DisableAction(3);
			FsmFloat targetX = fsm.FsmVariables.FindFsmFloat("Target X");
			state3.AddAction(delegate
			{
				targetX.Value = Extensions.GetPositionX(obj.transform) + (float)(((Random.value > 0.5f) ? 1 : (-1)) * Random.Range(6, 14));
			}, 3, everyFrame: false);
			FsmFloat idleY = fsm.FsmVariables.FindFsmFloat("Idle Y");
			FsmFloat swipeY = fsm.FsmVariables.FindFsmFloat("Swipe Y");
			FsmFloat targetY = fsm.FsmVariables.FindFsmFloat("Target Y");
			fsm.GetState("Idle").AddAction(FixYValues, 0, everyFrame: false);
			FixYValues();
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.setPlayerDataBool = "";
			component.PreInstantiate();
			GameObject instantiatedCorpse = component.GetInstantiatedCorpse((AttackTypes)1);
			RemoveConstrainPosition(instantiatedCorpse);
			PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(instantiatedCorpse, "Death");
			FsmState state4 = fsm2.GetState("Stagger");
			state4.DisableAction(6);
			state4.DisableAction(7);
			void FixYValues()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val, Vector2.op_Implicit(obj.transform.position), true))
				{
					float y = val.y;
					idleY.Value = y + 2.87f;
					swipeY.Value = y + 1.39f;
					targetY.Value = y - 2f;
				}
			}
		}

		public static void FixGms(GameObject obj)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			RemoveConstrainPosition(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.FsmVariables.FindFsmFloat("Idle Y").Value = Extensions.GetPositionY(obj.transform);
			FsmFloat ground1 = fsm.FsmVariables.FindFsmFloat("Stun Y");
			FsmFloat ground2 = fsm.FsmVariables.FindFsmFloat("Bell Stun Y");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("READY");
			}, 0, everyFrame: false);
			fsm.GetState("Ready").AddAction(delegate
			{
				fsm.SendEvent("BEGIN");
			}, -1, everyFrame: false);
			FsmState state = fsm.GetState("Intro Up");
			state.DisableAction(7);
			((Wait)state.actions[8]).time = FsmFloat.op_Implicit(0f);
			FixGround();
			void FixGround()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val, Vector2.op_Implicit(obj.transform.position), true))
				{
					float value = val.y + 3.3091f;
					ground1.Value = value;
					ground2.Value = value;
				}
			}
		}

		public static void FixAknidMother(GameObject obj)
		{
			obj.AddComponent<AknidMother>();
		}

		public static void FixSplinter(GameObject obj)
		{
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Branch 01 Idle");
		}

		public static void FinishSplinterFix(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Behaviour Base");
			fsm.fsmTemplate = null;
			fsm.GetState("Initial Position").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Reposition").DisableAction(3);
		}

		public static void FixSisterSplinter(GameObject obj)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, -1, everyFrame: false);
			fsm.GetState("Intro Shake").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Emerge Antic").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Reappear 4").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 1, everyFrame: false);
			fsm.GetState("Reappear 5").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Reappear 6").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Roar 4");
			state.DisableAction(0);
			state.DisableAction(2);
			((StartRoarEmitter)state.actions[3]).stunHero = FsmBool.op_Implicit(false);
			FsmState state2 = fsm.GetState("Roar End 4");
			state2.DisableAction(3);
			state2.DisableAction(4);
			state2.DisableAction(5);
			fsm.GetState("Can Summon?").DisableAction(1);
			FsmFloat xMid = fsm.FsmVariables.FindFsmFloat("Mid X");
			FsmFloat xMin = fsm.FsmVariables.FindFsmFloat("X Min");
			FsmFloat xMax = fsm.FsmVariables.FindFsmFloat("X Max");
			FsmFloat groundY = fsm.FsmVariables.FindFsmFloat("Ground Y");
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			GameObject instantiatedCorpse = component.GetInstantiatedCorpse((AttackTypes)1);
			FsmFloat deathGroundY = FSMUtility.LocateMyFSM(instantiatedCorpse, "Death").FsmVariables.FindFsmFloat("Ground Y");
			fsm.GetState("Idle").AddAction(AdjustAllPos, 0, everyFrame: false);
			fsm.GetState("Stun Hit").AddAction(AdjustYPos, 0, everyFrame: false);
			AdjustAllPos();
			fsm.GetState("Spike Summon").AddAction(delegate
			{
				obj.BroadcastEvent("TrySpikes");
			}, 0, everyFrame: false);
			fsm.GetState("Duo Fight").AddAction(delegate
			{
				obj.BroadcastEvent("TrySummon");
			}, 0, everyFrame: false);
			GameObject val = Object.Instantiate<GameObject>(_splinterSpikes);
			fsm.FsmVariables.FindFsmGameObject("Spikes Folder").Value = val;
			val.transform.position = obj.transform.position - new Vector3(45f, 16.88f, 0.008f);
			void AdjustAllPos()
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				xMid.Value = obj.transform.position.x;
				xMin.Value = obj.transform.position.x - 10.5f;
				xMax.Value = obj.transform.position.x + 10.5f;
				AdjustYPos();
			}
			void AdjustYPos()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val2 = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val2, Vector2.op_Implicit(obj.transform.position), true))
				{
					groundY.Value = val2.y - 1.8f;
					deathGroundY.Value = val2.y - 1.8f;
				}
			}
		}

		public static void FixFirstSinner(GameObject obj)
		{
			//IL_00d0: 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)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0534: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0633: Unknown result type (might be due to invalid IL or missing references)
			//IL_0872: Unknown result type (might be due to invalid IL or missing references)
			//IL_088c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c0: Unknown result type (might be due to invalid IL or missing references)
			RemoveConstrainPosition(obj);
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = fsm.GetState("Intro Roar End");
			state.DisableAction(0);
			state.DisableAction(1);
			FsmState state2 = fsm.GetState("P2 Tele Pause");
			state2.DisableAction(0);
			state2.AddAction(NoGravity, 0, everyFrame: false);
			fsm.GetState("Music Stop").DisableAction(0);
			FsmState state3 = fsm.GetState("P2 Roar");
			state3.DisableAction(0);
			state3.DisableAction(2);
			((StartRoarEmitter)state3.actions[4]).stunHero = FsmBool.op_Implicit(false);
			FsmState state4 = fsm.GetState("Roar");
			((StartRoarEmitter)state4.actions[6]).stunHero = FsmBool.op_Implicit(false);
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("REFIGHT START");
			}, -1, everyFrame: false);
			FsmState state5 = fsm.GetState("Refight Appear");
			state5.DisableAction(1);
			state5.DisableAction(5);
			FsmFloat groundY = fsm.FsmVariables.FindFsmFloat("Ground Y");
			FsmFloat slashY = fsm.FsmVariables.FindFsmFloat("Slash Y");
			FsmFloat teleMinX = fsm.FsmVariables.FindFsmFloat("Tele Min X");
			FsmFloat teleMaxX = fsm.FsmVariables.FindFsmFloat("Tele Max X");
			FsmFloat slashMinX = fsm.FsmVariables.FindFsmFloat("Slash Min X");
			FsmFloat slashMaxX = fsm.FsmVariables.FindFsmFloat("Slash Max X");
			FsmFloat teleY = fsm.FsmVariables.FindFsmFloat("Tele Y");
			FsmFloat bombTeleY1 = ((RandomFloatEither)fsm.GetState("Set Bomb").actions[3]).value1;
			FsmFloat bombTeleY2 = ((SetFloatValue)fsm.GetState("Set P2 Start").actions[3]).floatValue;
			GameObject val = Object.Instantiate<GameObject>(_loosePins);
			for (int i = 0; i < val.transform.childCount; i++)
			{
				GameObject gameObject = ((Component)val.transform.GetChild(i)).gameObject;
				RemoveConstrainPosition(gameObject);
				gameObject.SetActive(true);
				gameObject.transform.position = obj.transform.position + new Vector3(Random.Range(-2f, 2f), -1.25f);
			}
			val.SetActive(true);
			GameObject val2 = Object.Instantiate<GameObject>(_pinProjectiles);
			for (int j = 0; j < val2.transform.childCount; j++)
			{
				GameObject gameObject2 = ((Component)val2.transform.GetChild(j)).gameObject;
				gameObject2.SetActive(true);
				PlayMakerFSM val3 = FSMUtility.LocateMyFSM(gameObject2, "Control");
				val3.FsmVariables.FindFsmGameObject("Loose Pins").Value = val;
			}
			PlayMakerFSM val4 = FSMUtility.LocateMyFSM(val2, "Pattern Control");
			FsmFloat sceneCentreX = val4.FsmVariables.FindFsmFloat("Scene Centre X");
			FsmFloat pincerMinX = val4.FsmVariables.FindFsmFloat("Pincer Min X");
			FsmFloat pincerMaxX = val4.FsmVariables.FindFsmFloat("Pincer Max X");
			FsmState state6 = val4.GetState("Sweep R");
			FsmFloat sweepR1Y = ((SetPosition)state6.actions[5]).y;
			FsmFloat sweepR2Y = ((SetPosition)state6.actions[12]).y;
			FsmState state7 = val4.GetState("Sweep L");
			FsmFloat sweepL1Y = ((SetPosition)state7.actions[5]).y;
			FsmFloat sweepL2Y = ((SetPosition)state7.actions[12]).y;
			FsmState state8 = val4.GetState("Claw R");
			FsmFloat clawR1Y = ((SetPosition)state8.actions[5]).y;
			FsmFloat clawR2Y = ((SetPosition)state8.actions[12]).y;
			FsmFloat clawR3Y = ((SetPosition)state8.actions[19]).y;
			FsmFloat clawR1X = ((FloatOperator)state8.actions[3]).float1;
			FsmFloat clawR2X = ((FloatOperator)state8.actions[10]).float1;
			FsmFloat clawR3X = ((FloatOperator)state8.actions[17]).float1;
			FsmState state9 = val4.GetState("Claw L");
			FsmFloat clawL1Y = ((SetPosition)state9.actions[5]).y;
			FsmFloat clawL2Y = ((SetPosition)state9.actions[12]).y;
			FsmFloat clawL3Y = ((SetPosition)state9.actions[19]).y;
			FsmFloat clawL1X = ((FloatOperator)state9.actions[3]).float1;
			FsmFloat clawL2X = ((FloatOperator)state9.actions[10]).float1;
			FsmFloat clawL3X = ((FloatOperator)state9.actions[17]).float1;
			FsmState state10 = val4.GetState("Rain 1");
			FsmFloat rain1XMin = ((RandomFloat)state10.actions[0]).min;
			FsmFloat rain1XMax = ((RandomFloat)state10.actions[0]).max;
			FsmFloat rain1YMin = ((RandomFloat)state10.actions[1]).min;
			FsmFloat rain1YMax = ((RandomFloat)state10.actions[1]).max;
			FsmState state11 = val4.GetState("Rain 2");
			FsmFloat rain2YMin = ((RandomFloat)state11.actions[1]).min;
			FsmFloat rain2YMax = ((RandomFloat)state11.actions[1]).max;
			val2.SetActive(true);
			fsm.FsmVariables.FindFsmGameObject("Pin Projectiles").Value = val2;
			FsmString attackEvent = fsm.FsmVariables.FindFsmString("Attack Event");
			fsm.GetState("First Idle").DisableAction(0);
			FsmState state12 = fsm.GetState("Idle");
			state12.DisableAction(0);
			state12.AddAction(FixPositions, 0, everyFrame: false);
			FsmState state13 = fsm.GetState("Tele Out");
			state13.AddAction(NoGravity, 0, everyFrame: false);
			fsm.GetState("Phase Check").AddAction(FixPositions, 0, everyFrame: false);
			fsm.GetState("Tele In").AddAction(FixPositions, 0, everyFrame: false);
			fsm.GetState("After Tele").AddAction(FixPositions, 0, everyFrame: false);
			fsm.GetState("Death Stagger F").DisableAction(11);
			fsm.GetState("Fall").AddAction(delegate
			{
				if (rb2d.linearVelocityY == 0f)
				{
					fsm.SendEvent("LAND");
				}
			}, -1, everyFrame: true);
			fsm.GetState("Charge").AddAction(delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val8 = obj.transform.position - HeroController.instance.transform.position;
				if (((Vector3)(ref val8)).magnitude > 25f)
				{
					fsm.SendEvent("FINISHED");
				}
			}, 3, everyFrame: true);
			GameObject val5 = Object.Instantiate<GameObject>(_blasts);
			val5.SetActive(true);
			PlayMakerFSM[] componentsInChildren = val5.GetComponentsInChildren<PlayMakerFSM>();
			foreach (PlayMakerFSM val6 in componentsInChildren)
			{
				FsmState state14 = val6.GetState("Wait");
				if (state14 != null)
				{
					FsmFloat xMin = val6.FsmVariables.FindFsmFloat("X Min");
					FsmFloat xMax = val6.FsmVariables.FindFsmFloat("X Max");
					FsmState state15 = val6.GetState("Pos Low");
					FsmState state16 = val6.GetState("Pos High");
					FsmFloat lowMin = ((RandomFloat)state15.actions[0]).min;
					FsmFloat lowMax = ((RandomFloat)state15.actions[0]).max;
					FsmFloat highMin = ((RandomFloat)state16.actions[0]).min;
					FsmFloat highMax = ((RandomFloat)state16.actions[0]).max;
					state14.AddAction(delegate
					{
						xMin.Value = Extensions.GetPositionX(obj.transform) - 12f;
						xMax.Value = Extensions.GetPositionX(obj.transform) + 12f;
						lowMin.Value = groundY.Value - 0.09f;
						lowMax.Value = groundY.Value + 0.91f;
						highMin.Value = groundY.Value + 3.8f;
						highMax.Value = groundY.Value + 6.3f;
					}, 0, everyFrame: false);
				}
			}
			fsm.FsmVariables.FindFsmGameObject("Blasts").Value = val5;
			state12.transitions = state12.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			state13.transitions = state13.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			rb2d.gravityScale = 1f;
			rb2d.bodyType = (RigidbodyType2D)0;
			FixPositions();
			void FixPositions()
			{
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_024b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0260: Unknown result type (might be due to invalid IL or missing references)
				//IL_027f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_031b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0342: Unknown result type (might be due to invalid IL or missing references)
				//IL_0369: Unknown result type (might be due to invalid IL or missing references)
				//IL_0390: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03de: Unknown result type (might be due to invalid IL or missing references)
				if (fsm.ActiveStateName != "Tele In" || (attackEvent.Value != "BOMB" && rb2d.gravityScale == 0f))
				{
					Extensions.SetPositionX(obj.transform, Extensions.GetPositionX(obj.transform) + 0.2f);
					rb2d.gravityScale = 1f;
					rb2d.bodyType = (RigidbodyType2D)0;
				}
				float positionX = Extensions.GetPositionX(HeroController.instance.transform);
				FsmFloat obj2 = teleMinX;
				float value = (slashMinX.Value = positionX - 12.5f);
				obj2.Value = value;
				FsmFloat obj3 = teleMaxX;
				value = (slashMaxX.Value = positionX + 12.5f);
				obj3.Value = value;
				sceneCentreX.Value = Extensions.GetPositionX(obj.transform);
				pincerMinX.Value = sceneCentreX.Value - 7.5f;
				pincerMaxX.Value = sceneCentreX.Value + 7.5f;
				clawR1X.Value = sceneCentreX.Value - 14.2f;
				clawR2X.Value = sceneCentreX.Value - 7.2f;
				clawR3X.Value = sceneCentreX.Value - 0.2f;
				clawL1X.Value = sceneCentreX.Value + 14.2f;
				clawL2X.Value = sceneCentreX.Value + 7.2f;
				clawL3X.Value = sceneCentreX.Value + 0.2f;
				rain1XMin.Value = sceneCentreX.Value - 14f;
				rain1XMax.Value = sceneCentreX.Value - 10f;
				Vector2 val7 = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val7, new Vector2(positionX, Mathf.Max(obj.transform.position.y, HeroController.instance.transform.position.y) + 3f), true))
				{
					groundY.Value = val7.y + 1.68f;
					slashY.Value = val7.y + 5.98f;
					teleY.Value = val7.y + 1.68f;
					FsmFloat obj4 = bombTeleY1;
					value = (bombTeleY2.Value = val7.y + 4.48f);
					obj4.Value = value;
					FsmFloat obj5 = sweepL1Y;
					value = (sweepR1Y.Value = val7.y + 0.48f);
					obj5.Value = value;
					FsmFloat obj6 = sweepL2Y;
					value = (sweepR2Y.Value = val7.y + 7.48f);
					obj6.Value = value;
					FsmFloat obj7 = clawR1Y;
					value = (clawL1Y.Value = val7.y + 8.78f);
					obj7.Value = value;
					FsmFloat obj8 = clawR2Y;
					value = (clawL2Y.Value = val7.y + 9.78f);
					obj8.Value = value;
					FsmFloat obj9 = clawR3Y;
					value = (clawL3Y.Value = val7.y + 10.78f);
					obj9.Value = value;
					FsmFloat obj10 = rain1YMin;
					value = (rain2YMin.Value = val7.y + 9.48f);
					obj10.Value = value;
					FsmFloat obj11 = rain1YMax;
					value = (rain2YMax.Value = val7.y + 10.08f);
					obj11.Value = value;
				}
			}
			void NoGravity()
			{
				rb2d.gravityScale = 0f;
				rb2d.linearVelocityY = 0f;
			}
		}

		public static void FixRoachserver(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			AlertRange range = obj.GetComponentInChildren<AlertRange>();
			obj.layer = EnemiesLayer;
			FsmState state = fsm.GetState("BG Work");
			state.DisableAction(0);
			state.DisableAction(1);
			state.AddAction(delegate
			{
				if (range.IsHeroInRange())
				{
					fsm.SendEvent("BATTLE START");
				}
			}, 0, everyFrame: true);
		}

		public static PlayMakerFSM FixForebrother(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			FsmFloat xMin = val.FsmVariables.FindFsmFloat("X Min");
			FsmFloat xMax = val.FsmVariables.FindFsmFloat("X Max");
			val.GetState("Idle").AddAction(FixXPos, 0, everyFrame: false);
			return val;
			void FixXPos()
			{
				float positionX = Extensions.GetPositionX(HeroController.instance.transform);
				xMin.Value = positionX - 11f;
				xMax.Value = positionX + 11f;
			}
		}

		public static void FixSignis(GameObject obj)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FixForebrother(obj);
			AlertRange range = obj.GetComponentInChildren<AlertRange>();
			fsm.GetState("Pointing").AddAction(delegate
			{
				if (range.IsHeroInRange())
				{
					fsm.SendEvent("BATTLE START");
				}
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Death Hit");
			state.DisableAction(15);
			state.DisableAction(16);
			((CheckYPosition)fsm.GetState("Death Fly").actions[10]).compareTo.Value = obj.transform.position.y - 1f;
			((StartRoarEmitter)fsm.GetState("Roar").actions[3]).stunHero = FsmBool.op_Implicit(false);
			FsmState state2 = fsm.GetState("Roar End");
			state2.DisableAction(9);
			state2.DisableAction(10);
			fsm.GetState("P2 Roar End").AddAction(delegate
			{
				obj.BroadcastEvent("TrySummon");
			}, 0, everyFrame: false);
			fsm.GetState("P3 Roar End").AddAction(delegate
			{
				obj.BroadcastEvent("TrySummon");
			}, 0, everyFrame: false);
			fsm.GetState("P4 Roar End").AddAction(delegate
			{
				obj.BroadcastEvent("TrySummon");
			}, 0, everyFrame: false);
		}

		public static void FixGron(GameObject obj)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			PlayMakerFSM fsm = FixForebrother(obj);
			fsm.GetState("Start Pause").DisableAction(0);
			((CheckYPosition)fsm.GetState("Death Fly").actions[8]).compareTo.Value = obj.transform.position.y - 1f;
			FsmState state = fsm.GetState("Init");
			state.transitions = Array.Empty<FsmTransition>();
			state.AddAction(delegate
			{
				fsm.SetState("Entry Fall");
			}, 0, everyFrame: false);
			ConvertBoolToString val = (ConvertBoolToString)fsm.GetState("Shout").actions[5];
			val.trueString = val.falseString;
		}

		public static void FixPhantom(GameObject obj)
		{
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			RemoveConstrainPosition(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			GameObject pin = fsm.FsmVariables.FindFsmGameObject("Pin Projectile").Value;
			Collider2D pc = pin.GetComponent<Collider2D>();
			pc.isTrigger = false;
			pc.sharedMaterial = PinMaterial;
			Rigidbody2D prb2d = pin.GetComponent<Rigidbody2D>();
			prb2d.bodyType = (RigidbodyType2D)0;
			prb2d.gravityScale = 0f;
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("PHANTOM START");
			}, -1, everyFrame: false);
			fsm.GetState("Appear").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, -1, everyFrame: false);
			fsm.GetState("Start Pause").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, -1, everyFrame: false);
			FsmFloat leftX = fsm.FsmVariables.FindFsmFloat("Left X");
			FsmFloat rightX = fsm.FsmVariables.FindFsmFloat("Right X");
			RandomFloat val = (RandomFloat)fsm.GetState("Set A Throw").actions[2];
			FsmFloat aThrowMin = val.min;
			FsmFloat aThrowMax = val.max;
			FsmFloat fogin2Y = ((SetPosition)fsm.GetState("Fog In 2").actions[0]).y;
			FsmFloat aThrowRequirement = ((FloatTestToBool)fsm.GetState("In Air").actions[7]).float2;
			FsmFloat pullY = ((FloatCompare)fsm.GetState("A Dash").actions[12]).float2;
			FsmFloat dragoonY = ((FloatCompare)fsm.GetState("Dragoon Launch").actions[8]).float2;
			fsm.GetState("To Idle").AddAction(delegate
			{
				Collider2D[] componentsInChildren = obj.GetComponentsInChildren<Collider2D>(true);
				foreach (Collider2D val3 in componentsInChildren)
				{
					Physics2D.IgnoreCollision(pc, val3);
				}
			}, 0, everyFrame: false);
			fsm.GetState("Idle").AddAction(FixPositions, 0, everyFrame: false);
			fsm.GetState("Range Check").AddAction(FixPositions, 0, everyFrame: false);
			FsmState state = fsm.GetState("Pos");
			state.DisableAction(3);
			FsmState state2 = fsm.GetState("G Throw");
			state2.DisableAction(15);
			state2.DisableAction(16);
			FsmState state3 = fsm.GetState("G Pull Wait");
			state3.DisableAction(3);
			state3.DisableAction(4);
			state2.AddAction(Thunk, -1, everyFrame: true);
			state3.AddAction(Thunk, -1, everyFrame: true);
			FsmState state4 = fsm.GetState("A Throw");
			state4.DisableAction(13);
			state4.DisableAction(14);
			state4.DisableAction(15);
			((SetVelocityAsAngle)state4.actions[9]).everyFrame = false;
			((FaceAngle)state4.actions[10]).everyFrame = false;
			FsmState state5 = fsm.GetState("A Pull Wait");
			state5.DisableAction(3);
			state5.DisableAction(4);
			state5.DisableAction(5);
			state5.AddAction(ThunkAir, -1, everyFrame: true);
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			fsm.GetState("Dragoon Down").AddAction(ClearVelocity, 0, everyFrame: true);
			fsm.GetState("Fog In").AddAction(ClearVelocity, 0, everyFrame: false);
			fsm.GetState("Dragoon Blast").AddAction(delegate
			{
				obj.BroadcastEvent("Slam");
			}, 0, everyFrame: false);
			FsmState state6 = fsm.GetState("Dragoon End");
			state6.AddAction(ClearVelocity, 0, everyFrame: false);
			FsmState state7 = fsm.GetState("Hero Death Check");
			state7.transitions = state7.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			FsmState state8 = fsm.GetState("To Idle");
			state8.transitions = state8.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			fsm.GetState("In Air").AddAction(delegate
			{
				rb2d.gravityScale = 2.5f;
			}, 0, everyFrame: false);
			state8.AddAction(delegate
			{
				rb2d.gravityScale = 2.5f;
			}, 0, everyFrame: false);
			FsmState state9 = fsm.GetState("Final Parry");
			for (int i = 0; i <= 18; i++)
			{
				state9.DisableAction(i);
			}
			state9.AddAction(delegate
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				obj.GetComponent<HealthManager>().SetDead();
				obj.GetComponent<SpriteFlash>().Flash(new Color(1f, 1f, 1f), 0.8f, 0f, 0.12f, 0.25f, 0f, false, 0, 0, false);
				obj.layer = 2;
				rb2d.constraints = (RigidbodyConstraints2D)7;
				obj.GetComponent<tk2dSpriteAnimator>().Play("Death Stagger");
				fsm.SetState("Blood Stream");
				pin.SetActive(false);
				if (!Object.op_Implicit((Object)(object)obj.GetComponent<DisableDeathSlowdown>()))
				{
					GameManager.instance.FreezeMoment((FreezeMomentTypes)10, (Action)null);
				}
			}, 0, everyFrame: false);
			FsmState state10 = fsm.GetState("Death Explode");
			state10.transitions = Array.Empty<FsmTransition>();
			state10.AddAction(delegate
			{
				Object.Destroy((Object)(object)obj);
			}, -1, everyFrame: false);
			fsm.FsmGlobalTransitions.First((FsmTransition o) => o.EventName == "FINAL BLOCK").fsmEvent = FsmEvent.FindEvent("ZERO HP");
			void ClearVelocity()
			{
				rb2d.gravityScale = 0f;
				rb2d.bodyType = (RigidbodyType2D)0;
				rb2d.linearVelocityY = 0f;
			}
			void FixPositions()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				float positionX = Extensions.GetPositionX(HeroController.instance.transform);
				leftX.Value = positionX - 8.5f;
				rightX.Value = positionX + 8.5f;
				Vector2 val2 = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val2, Vector2.op_Implicit(obj.transform.position), true))
				{
					aThrowMin.Value = val2.y + 6f;
					aThrowMax.Value = val2.y + 8f;
					fogin2Y.Value = val2.y + 8f;
					dragoonY.Value = val2.y + 20.5f;
					pullY.Value = val2.y + 3f;
					aThrowRequirement.Value = val2.y + 6f;
				}
			}
			void Thunk()
			{
				if (prb2d.linearVelocityX == 0f)
				{
					fsm.SendEvent("FINISHED");
				}
				prb2d.linearVelocityY = 0f;
			}
			void ThunkAir()
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				if (prb2d.linearVelocityX == 0f || prb2d.linearVelocityY == 0f)
				{
					fsm.SendEvent("FINISHED");
					prb2d.linearVelocity = Vector2.zero;
				}
			}
		}

		public static void FixLostGarmondPreload(GameObject obj)
		{
			BlackThreadState component = obj.GetComponent<BlackThreadState>();
			BlackThreader.CustomBlackThreadState customBlackThreadState = obj.AddComponent<BlackThreader.CustomBlackThreadState>();
			customBlackThreadState.customAttack = component.attacks[0];
			((BlackThreadState)customBlackThreadState).extraSpriteRenderers = obj.GetComponentsInChildren<SpriteRenderer>(true);
			((BlackThreadState)customBlackThreadState).extraMeshRenderers = obj.GetComponentsInChildren<MeshRenderer>(true);
			HealthManager component2 = obj.GetComponent<HealthManager>();
			component2.blackThreadState = (BlackThreadState)(object)customBlackThreadState;
			component2.hasBlackThreadState = true;
			((BlackThreadState)customBlackThreadState).useCustomHPMultiplier = true;
			((BlackThreadState)customBlackThreadState).customHPMultiplier = 1f;
			Object.Destroy((Object)(object)component);
		}

		public static void FixLostGarmond(GameObject obj)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			AlertRange range = ((Component)obj.transform.Find("Stomp Range")).GetComponent<AlertRange>();
			fsm.GetState("Out of Start Range").AddAction(delegate
			{
				if (range.IsHeroInRange())
				{
					fsm.SendEvent("ENTER");
				}
			}, -1, everyFrame: true);
			fsm.GetState("Roar Antic").DisableAction(1);
			((StartRoarEmitter)fsm.GetState("Intro Roar").actions[4]).stunHero = FsmBool.op_Implicit(false);
			FsmState state = fsm.GetState("Sting");
			state.DisableAction(0);
			state.DisableAction(1);
			FsmState state2 = fsm.GetState("Roar End");
			state2.DisableAction(1);
			state2.DisableAction(2);
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			GameObject corpse = component.GetInstantiatedCorpse((AttackTypes)1);
			corpse.RemoveComponent<ConstrainPosition>();
			FsmState state3 = FSMUtility.LocateMyFSM(corpse, "Control").GetState("Blow");
			state3.DisableAction(5);
			state3.transitions = Array.Empty<FsmTransition>();
			state3.AddAction(delegate
			{
				corpse.SetActive(false);
			}, -1, everyFrame: false);
		}

		public static void FixServitorBoran(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			Transform child = obj.transform.Find("Legs Container").GetChild(0).GetChild(0);
			((Component)child).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			((Component)child.GetChild(0).Find("Roll Collider")).gameObject.layer = LayerMask.NameToLayer("Enemies");
			obj.AddComponent<Boran>();
		}

		public static void FixServitorIgnim(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			Extensions.SetRotation2D(obj.transform, 0f);
			Extensions.SetPositionZ(obj.transform, 0.006f);
		}

		public static void FixCogworkClapperAnim(GameObject obj)
		{
			KeepActiveRemoveConstrainPos(obj);
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			((Component)obj.transform.Find("Hero Solid")).gameObject.SetActive(false);
			obj.GetComponent<HealthManager>().invincible = false;
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Idle");
		}

		public static void FixCogworkClapper(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Sleep").AddAction(delegate
			{
				fsm.SetState("Idle");
				((Behaviour)obj.GetComponent<DamageHero>()).enabled = true;
			}, 0, everyFrame: false);
			fsm.GetState("Roll Check").DisableAction(0);
			fsm.GetState("Floor").DisableAction(8);
		}

		public static void FixGiantFlea(GameObject obj)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = fsm.GetState("Init");
			state.DisableAction(4);
			((StartRoarEmitter)fsm.GetState("Roar").actions[5]).stunHero = FsmBool.op_Implicit(false);
			fsm.GetState("Revisit").DisableAction(1);
			FsmState state2 = fsm.GetState("Roar End");
			state2.DisableAction(0);
			state2.DisableAction(1);
		}

		public static void FixPharlidDiver(GameObject obj)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Behaviour");
			val.FsmVariables.FindFsmGameObject("Home").Value = new GameObject(((Object)obj).name + " Home");
		}

		public static void FixShardillard(GameObject obj)
		{
			KeepActive(obj);
			obj.AddComponent<Shardillard>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Charge").DisableAction(12);
			fsm.GetState("Terrain Effects").AddAction(delegate
			{
				obj.BroadcastEvent("OnBounce");
			}, 0, everyFrame: false);
		}

		public static void FixWingedFurm(GameObject obj)
		{
			FsmState state = FSMUtility.LocateMyFSM(obj, "Tween").GetState("Init");
			state.DisableAction(0);
		}

		public static void FixFurm(GameObject obj)
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			GameObject val = new GameObject(((Object)obj).name + " Dig Pos");
			val.transform.position = obj.transform.position;
			GameObject value = val;
			fsm.FsmVariables.FindFsmGameObject("Dig Min X Obj").Value = value;
			fsm.FsmVariables.FindFsmGameObject("Dig Max X Obj").Value = value;
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, -1, everyFrame: false);
			fsm.GetState("Positioning Check").DisableAction(3);
			FsmState state = fsm.GetState("Set To Ground");
			state.DisableAction(4);
			state.DisableAction(5);
			FsmState state2 = fsm.GetState("Set To Wall L");
			state2.DisableAction(5);
			state2.DisableAction(6);
			FsmState state3 = fsm.GetState("Set To Wall R");
			state3.DisableAction(5);
			state3.DisableAction(6);
			FsmState state4 = fsm.GetState("Set To Roof");
			state4.DisableAction(5);
			state4.DisableAction(6);
			fsm.GetState("Surface Dig Prepare").AddAction(delegate
			{
				fsm.SendEvent("START");
			}, 0, everyFrame: false);
			fsm.GetState("Surface Dig").AddAction(delegate
			{
				fsm.SendEvent("EMERGE");
			}, 0, everyFrame: false);
		}

		public static void FixPatroller(GameObject obj)
		{
			obj.AddComponent<PatrollerFix>();
		}

		public static void FixCogworkSpine(GameObject obj)
		{
			FixPatroller(obj);
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Fly");
		}

		public static void FixFlintbeetlePreload(GameObject obj)
		{
			KeepActiveRemoveConstrainPos(obj);
			Object.Destroy((Object)(object)((Component)obj.transform.Find("CamLock")).gameObject);
		}

		public static void FixFlintbeetle(GameObject obj)
		{
			obj.AddComponent<Flintbeetle>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = fsm.GetState("Emerge");
			state.DisableAction(13);
			state.DisableAction(14);
			FsmState state2 = fsm.GetState("Death");
			state2.DisableAction(1);
			state2.DisableAction(2);
		}

		public static void FixCrawJurorPreload(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			Extensions.SetPositionZ(obj.transform, 0.006f);
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Idle");
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			obj.layer = EnemiesLayer;
		}

		public static void FixTallcrawJuror(GameObject obj)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)obj.GetComponent<MeshRenderer>()).enabled = true;
			((tk2dBaseSprite)obj.GetComponent<tk2dSprite>()).color = Color.white;
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.GetState("Roost L").DisableAction(0);
			val.GetState("Roost R").DisableAction(0);
			val.FsmVariables.FindFsmBool("Spawner").Value = false;
			val.FsmVariables.FindFsmBool("z_Summon").Value = false;
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			obj.GetComponent<tk2dSpriteAnimator>().Play("Idle");
		}

		public static void FixTinyCrawJuror(GameObject obj)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Behaviour");
			FsmState state = fsm.GetState("Set FG");
			state.DisableAction(1);
			state.DisableAction(2);
			fsm.GetState("Init").AddAction(delegate
			{
				obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
				obj.layer = EnemiesLayer;
				fsm.SendEvent("FG");
			}, 14, everyFrame: false);
			FsmState state2 = fsm.GetState("Flap");
			state2.DisableAction(8);
			((GetPosition)state2.actions[7]).y = ((RandomFloat)state2.actions[8]).storeResult;
			((Renderer)obj.GetComponent<MeshRenderer>()).enabled = true;
			((tk2dBaseSprite)obj.GetComponent<tk2dSprite>()).color = Color.white;
		}

		public static void FixCrawJuror(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.FsmVariables.FindFsmBool("Spawner").Value = false;
			val.FsmVariables.FindFsmBool("z_Summon").Value = false;
		}

		public static void FixUnderworksArenaEnemy(GameObject obj)
		{
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Idle");
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			((Renderer)obj.GetComponent<MeshRenderer>()).enabled = true;
			obj.layer = EnemiesLayer;
		}

		public static void FixDriznit(GameObject obj)
		{
			tk2dSpriteAnimator component = obj.GetComponent<tk2dSpriteAnimator>();
			component.defaultClipId = component.GetClipIdByName("Ceiling Hang");
			obj.AddComponent<Driznit>();
		}

		public static void FixGargantGloom(GameObject obj)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.FsmVariables.FindFsmGameObject("Home").Value = new GameObject(((Object)obj).name + " Home");
			fsm.GetState("Start L").DisableAction(0);
			fsm.GetState("Start R").DisableAction(0);
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("WAKE");
			}, -1, everyFrame: false);
		}

		public static void FixGloomsac(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.FsmVariables.FindFsmBool("Hornet Dead").Value = false;
			val.GetState("Capture").AddAction(delegate
			{
				obj.BroadcastEvent("FirstDeath");
				obj.BroadcastEvent("OnDeath");
			}, -1, everyFrame: false);
		}

		public static void FixSeth(GameObject obj)
		{
			KeepActiveRemoveConstrainPos(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Stun Start 2").DisableAction(5);
			FsmState state = fsm.GetState("Rage Roar End");
			state.DisableAction(1);
			state.DisableAction(2);
			FsmState state2 = fsm.GetState("Idle");
			state2.transitions = state2.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			FsmState state3 = fsm.GetState("Attack Choice");
			state3.transitions = state3.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			GameObject val = Object.Instantiate<GameObject>(_shieldTrail);
			val.SetActive(true);
			fsm.FsmVariables.FindFsmGameObject("Pt Shield Trail").Value = val;
			FsmFloat tmix = fsm.FsmVariables.FindFsmFloat("Tele Min X");
			FsmFloat tmax = fsm.FsmVariables.FindFsmFloat("Tele Max X");
			fsm.FsmVariables.FindFsmFloat("Jump X").value = Extensions.GetPositionX(obj.transform);
			FsmFloat gy = fsm.FsmVariables.FindFsmFloat("Ground Y");
			FsmFloat ay = fsm.FsmVariables.FindFsmFloat("Air Y");
			Transform shield = obj.transform.Find("Shield Projectile");
			PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(((Component)shield).gameObject, "Control");
			FsmState state4 = fsm2.GetState("Fly");
			for (int i = 2; i <= 8; i++)
			{
				state4.DisableAction(i);
			}
			state4.AddAction(delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				RaycastHit2D val3 = Physics2D.Raycast(Vector2.op_Implicit(shield.position), Vector2.down, 4f);
				if (RaycastHit2D.op_Implicit(val3))
				{
					fsm.SendEvent("FLOOR");
				}
			}, -1, everyFrame: true);
			fsm.GetState("Attack Choice").AddAction(AdjustPositions, 0, everyFrame: false);
			AdjustPositions();
			void AdjustPositions()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: 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)
				float positionX = Extensions.GetPositionX(HeroController.instance.transform);
				tmix.Value = positionX - 12.5f;
				tmax.Value = positionX + 12.5f;
				Vector2 val2 = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val2, Vector2.op_Implicit(obj.transform.position), true))
				{
					gy.Value = val2.y + 0.2f;
					ay.Value = val2.y + 6.1f;
				}
			}
		}

		public static void FixCorrcrustKaraka(GameObject obj)
		{
			FixSpearSpawned(obj);
			RemoveConstrainPosition(obj);
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = val.GetState("Stomp Rise");
			state.DisableAction(2);
			state.DisableAction(3);
			FsmFloat targetX = val.FsmVariables.FindFsmFloat("Target X");
			FsmFloat targetY = val.FsmVariables.FindFsmFloat("Target Y");
			float runningTime = 0f;
			float fromX = 0f;
			float fromY = 0f;
			state.AddAction(delegate
			{
				runningTime = 0f;
				fromX = Extensions.GetPositionX(obj.transform);
				fromY = Extensions.GetPositionY(obj.transform);
			}, 2, everyFrame: false);
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			state.AddAction(delegate
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				runningTime += Time.deltaTime;
				float value = Mathf.Clamp01(runningTime * 2f);
				rb2d.MovePosition(new Vector2(EaseInOutSine(fromX, targetX.Value, value), EaseOutCubic(fromY, targetY.Value, value)));
			}, 3, everyFrame: true);
		}

		private static float EaseOutCubic(float start, float end, float value)
		{
			value -= 1f;
			end -= start;
			return end * (float)((double)(value * value * value) + 1.0) + start;
		}

		private static float EaseInOutSine(float start, float end, float value)
		{
			end -= start;
			return (float)((0.0 - (double)end) / 2.0 * ((double)Mathf.Cos((float)(3.1415927410125732 * (double)value / 1.0)) - 1.0)) + start;
		}

		public static void FixCrawfather(GameObject obj)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("BG Idle").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, -1, everyFrame: false);
			fsm.GetState("Emerge Announce").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Emerge Antic").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Emerge").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			((StartRoarEmitter)fsm.GetState("Roar").actions[1]).stunHero = FsmBool.op_Implicit(false);
			FsmFloat flapY = fsm.FsmVariables.FindFsmFloat("Flap Y");
			fsm.GetState("Idle").AddAction(AdjustFlapY, 0, everyFrame: false);
			fsm.GetState("Range Check").AddAction(AdjustFlapY, 0, everyFrame: false);
			fsm.GetState("Call").AddAction(delegate
			{
				obj.BroadcastEvent("TrySummon");
			}, 0, everyFrame: false);
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			FsmState state = fsm.GetState("Launch");
			float runningTime = 0f;
			float fromY = 0f;
			state.DisableAction(3);
			state.AddAction(delegate
			{
				runningTime = 0f;
				fromY = Extensions.GetPositionY(obj.transform);
			}, 3, everyFrame: false);
			state.AddAction(delegate
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				runningTime += Time.deltaTime;
				float num = Mathf.Clamp01(runningTime * 2.22f);
				rb2d.MovePosition(new Vector2(Extensions.GetPositionX(obj.transform), EaseOutCubic(fromY, flapY.Value, num)));
				if (num >= 1f)
				{
					fsm.SendEvent("FINISHED");
				}
			}, 4, everyFrame: true);
			FsmState state2 = fsm.GetState("Dive");
			float firstMoveTime = 0f;
			state2.AddAction(delegate
			{
				firstMoveTime = Time.time;
			}, -1, everyFrame: false);
			state2.AddAction(delegate
			{
				if (!(Time.time - firstMoveTime < 0.1f) && Mathf.Abs(rb2d.linearVelocityY) < 0.05f)
				{
					fsm.SendEvent("LAND");
				}
			}, -1, everyFrame: true);
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(component.GetInstantiatedCorpse((AttackTypes)1), "Death");
			fsm2.GetState("Stagger").DisableAction(5);
			AdjustFlapY();
			void AdjustFlapY()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = default(Vector2);
				if (HeroController.instance.TryFindGroundPoint(ref val, Vector2.op_Implicit(obj.transform.position), true))
				{
					flapY.Value = val.y + 6.5f;
				}
			}
		}

		public static void FixKhann(GameObject obj)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			GameObject spears = new GameObject(((Object)obj).name + " Spears");
			GameObject longSpear = null;
			GameObject shootSpikes = null;
			foreach (KeyValuePair<string, GameObject> spearObject in SpearObjects)
			{
				spearObject.Deconstruct(out var key, out var value);
				string text = key;
				GameObject val = value;
				GameObject val2 = Object.Instantiate<GameObject>(val, spears.transform);
				fsm.FsmVariables.FindFsmGameObject(text).Value = val2;
				PlayMakerFSM spearFsm = FSMUtility.LocateMyFSM(val2, "Control");
				if (Object.op_Implicit((Object)(object)spearFsm))
				{
					spearFsm.GetState("Init")?.AddAction(delegate
					{
						FsmGameObject val4 = spearFsm.FsmVariables.FindFsmGameObject("Coral King");
						if (val4 != null)
						{
							val4.Value = obj;
						}
					}, -1, everyFrame: false);
				}
				string text2 = text;
				string text3 = text2;
				if (!(text3 == "Shoot Spikes"))
				{
					if (text3 == "Long Spear")
					{
						longSpear = val2;
					}
				}
				else
				{
					((SendEventByName)fsm.GetState("Ground Hit").actions[0]).eventTarget.fsmComponent = spearFsm;
					shootSpikes = val2;
				}
			}
			BlackThreader.BlackThreadData blackThreadData = obj.AddComponent<BlackThreader.BlackThreadData>();
			blackThreadData.SingCheck = () => fsm.ActiveStateName.Contains("Antic");
			blackThreadData.OnBlackThread = delegate
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				DamageHero[] componentsInChildren = spears.GetComponentsInChildren<DamageHero>(true);
				foreach (DamageHero val3 in componentsInChildren)
				{
					val3.damagePropertyFlags = (DamagePropertyFlags)(val3.damagePropertyFlags | 8);
				}
			};
			float startingX = Extensions.GetPositionX(obj.transform);
			fsm.GetState("Hop Away 1").AddAction(delegate
			{
				if (Mathf.Abs(Extensions.GetPositionX(obj.transform) - startingX) > 12.5f && Random.value > 0.5f)
				{
					fsm.SendEvent("JUMP OVER");
				}
			}, -1, everyFrame: false);
			fsm.GetState("Dormant").AddAction(delegate
			{
				((Renderer)obj.GetComponent<MeshRenderer>()).enabled = true;
				obj.GetComponent<HealthManager>().IsInvincible = false;
				fsm.SendEvent("BATTLE START");
			}, -1, everyFrame: false);
			fsm.GetState("Start Pos").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Drop In").AddAction(delegate
			{
				fsm.SendEvent("LAND");
			}, 0, everyFrame: false);
			fsm.GetState("Intro Land").DisableAction(6);
			((StartRoarEmitter)fsm.GetState("Intro Roar").actions[2]).stunHero = FsmBool.op_Implicit(false);
			FsmState state = fsm.GetState("Intro End");
			state.DisableAction(1);
			state.DisableAction(2);
			FsmState state2 = fsm.GetState("Phase Check");
			state2.transitions = state2.transitions.Where((FsmTransition trans) => trans.EventName != "HORNET DEAD").ToArray();
			FsmState state3 = fsm.GetState("Pull Out");
			fsm.FsmGlobalTransitions.First((FsmTransition o) => o.EventName == "ZERO HP").toFsmState = state3;
			state3.DisableAction(13);
			state3.AddAction(delegate
			{
				obj.GetComponent<Rigidbody2D>().constraints = (RigidbodyConstraints2D)7;
				obj.layer = 2;
			}, 0, everyFrame: false);
			state3.AddAction(delegate
			{
				fsm.SendEvent("LAND");
			}, -1, everyFrame: false);
			fsm.GetState("Hornet Land").AddAction(delegate
			{
				fsm.SendEvent("NEXT");
			}, 0, everyFrame: false);
			fsm.GetState("Seth Check").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Get Item").AddAction(delegate
			{
				fsm.SendEvent("NEXT");
			}, 0, everyFrame: false);
			FsmState state4 = fsm.GetState("Final Rumble");
			state4.DisableAction(0);
			((Wait)state4.actions[1]).time = FsmFloat.op_Implicit(20f);
			FsmState state5 = fsm.GetState("Event");
			state5.DisableAction(0);
			state5.AddAction(delegate
			{
				Object.Destroy((Object)(object)obj);
			}, -1, everyFrame: false);
			FSMUtility.LocateMyFSM(obj, "Crust Up").GetState("Finish").AddAction(delegate
			{
				if (Object.op_Implicit((Object)(object)obj.GetComponent<BlackThreadState>()))
				{
					((Renderer)obj.GetComponent<MeshRenderer>()).enabled = false;
				}
			}, -1, everyFrame: false);
			FsmFloat centreX = fsm.FsmVariables.FindFsmFloat("Centre X");
			FsmFloat groundY = fsm.FsmVariables.FindFsmFloat("Ground Y");
			FsmFloat airY = fsm.FsmVariables.FindFsmFloat("Air Jab Pos");
			fsm.GetState("Phase Check").AddAction(FixPositions, 0, everyFrame: false);
			fsm.GetState("Next Move").AddAction(FixPositions, 0, everyFrame: false);
			FixPositions();
			void FixPositions()
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				centreX.Value = Extensions.GetPositionX(obj.transform);
				Extensions.SetPositionX(shootSpikes.transform, Extensions.GetPositionX(obj.transform));
				Extensions.SetPositionX(longSpear.transform, Extensions.GetPositionX(obj.transform));
				float num = HeroController.instance.FindGroundPointY(obj.transform.position.x, obj.transform.position.y, true);
				groundY.Value = num;
				airY.Value = num + 6.55f;
				Extensions.SetPositionY(shootSpikes.transform, num + 10f);
				if (!((Component)longSpear.transform.GetChild(0)).gameObject.activeSelf && !((Component)longSpear.transform.GetChild(1)).gameObject.activeSelf)
				{
					Extensions.SetPositionY(longSpear.transform, num + 7f);
				}
			}
		}

		public static void FixPinstress(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.FsmVariables.FindFsmFloat("Centre X").Value = Extensions.GetPositionX(obj.transform);
			val.FsmVariables.FindFsmFloat("Jump X Min").Value = Extensions.GetPositionX(obj.transform) - 7.5f;
			val.FsmVariables.FindFsmFloat("Jump X Max").Value = Extensions.GetPositionX(obj.transform) + 7.5f;
			val.FsmVariables.FindFsmFloat("Ground Y").Value = Extensions.GetPositionY(obj.transform) - 1.9273f;
		}

		public static void FixPlasmified(GameObject obj)
		{
			FSMUtility.LocateMyFSM(obj, "Control").GetState("Extract Kill").AddAction(delegate
			{
				obj.BroadcastEvent("OnDeath");
			}, 0, everyFrame: false);
		}

		public static void FixPlasmidas(GameObject obj)
		{
			FixPlasmified(obj);
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.rotateCorpse = true;
			component.PreInstantiate();
			((Corpse)component.GetInstantiatedCorpse((AttackTypes)1).GetComponent<CorpseRegular>()).resetRotation = false;
		}

		public static void RotateCorpse(GameObject obj)
		{
			obj.GetComponent<EnemyDeathEffects>().rotateCorpse = true;
		}

		public static void FixChoristor(GameObject obj)
		{
			obj.AddComponent<FakePersistentMarker>();
		}

		public static void FixUndercrank(GameObject obj)
		{
			FixUnderworksArenaEnemy(obj);
			obj.AddComponent<FakePersistentMarker>();
		}

		public static void FixSkarr(GameObject obj)
		{
			Extensions.SetRotation2D(obj.transform, 0f);
			obj.RemoveComponent<EnemyEdgeControl>();
		}

		public static void FixTormentedTrobbio(GameObject obj)
		{
			PlayMakerFSM fsm2 = FixTrobbio(obj, _tflares, _tfloor, _tbursts, delegate(float y, PlayMakerFSM fsm)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				((SetFsmFloat)fsm.GetState("Tornado Start").actions[9]).setValue = FsmFloat.op_Implicit(y + 3.21f);
			});
			fsm2.GetState("Wait").AddAction(delegate
			{
				fsm2.SendEvent("ENTER");
			}, 0, everyFrame: false);
			FsmState state = fsm2.GetState("Start Pause");
			state.DisableAction(0);
			state.DisableAction(1);
			state.DisableAction(2);
			state.DisableAction(3);
			state.AddAction(delegate
			{
				fsm2.SetState("Start Idle");
			}, 0, everyFrame: false);
			FsmState state2 = fsm2.GetState("Flash Antic");
			state2.DisableAction(9);
			float runningTime = 0f;
			float fromX = 0f;
			float fromY = 0f;
			state2.AddAction(delegate
			{
				runningTime = 0f;
				fromX = Extensions.GetPositionX(obj.transform);
				fromY = Extensions.GetPositionY(obj.transform);
			}, 9, everyFrame: false);
			FsmFloat targetY = fsm2.FsmVariables.FindFsmFloat("Target Y");
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			state2.AddAction(delegate
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				runningTime += Time.deltaTime;
				float value2 = Mathf.Clamp01(runningTime * 2.5f);
				rb2d.MovePosition(new Vector2(fromX, EaseOutSine(fromY, targetY.Value, value2)));
			}, 10, everyFrame: true);
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			GameObject corpse = component.GetInstantiatedCorpse((AttackTypes)1);
			PlayMakerFSM fsm3 = FSMUtility.LocateMyFSM(corpse, "Control");
			FsmState state3 = fsm3.GetState("Stagger");
			state3.DisableAction(2);
			state3.DisableAction(3);
			state3.DisableAction(15);
			FsmState state4 = fsm3.GetState("Leave End");
			state4.transitions = Array.Empty<FsmTransition>();
			state4.AddAction(delegate
			{
				Object.Destroy((Object)(object)corpse);
			}, -1, everyFrame: false);
			static float EaseOutSine(float start, float end, float value)
			{
				end -= start;
				return end * Mathf.Sin((float)((double)value / 1.0 * 1.5707963705062866)) + start;
			}
		}

		public static void FixRegularTrobbio(GameObject obj)
		{
			PlayMakerFSM fsm = FixTrobbio(obj, _flares, _floor, _bursts);
			fsm.GetState("Death Air").AddAction(delegate
			{
				fsm.fsm.globalTransitions = Array.Empty<FsmTransition>();
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Wait Refight");
			state.DisableAction(0);
			state.DisableAction(1);
			state.AddAction(delegate
			{
				fsm.SetState("Start Idle");
			}, 0, everyFrame: false);
			fsm.GetState("Death Hit").DisableAction(37);
			fsm.GetState("Death Fling").DisableAction(5);
			fsm.GetState("Death Air").DisableAction(4);
		}

		public static PlayMakerFSM FixTrobbio(GameObject obj, GameObject flareObj, GameObject floorObj, GameObject burstObj, [CanBeNull] Action<float, PlayMakerFSM> yPos = null)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Expected O, but got Unknown
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Expected O, but got Unknown
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Expected O, but got Unknown
			GameObject flares = Object.Instantiate<GameObject>(flareObj);
			((Object)flares).name = ((Object)obj).name + " Flares";
			GameObject floor = Object.Instantiate<GameObject>(floorObj);
			((Object)floor).name = ((Object)obj).name + " Floor";
			GameObject bursts = Object.Instantiate<GameObject>(burstObj);
			((Object)bursts).name = ((Object)obj).name + " Bursts";
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = fsm.GetState("Tornado Turn");
			state.AddAction((FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.01f)
			});
			fsm.FsmVariables.FindFsmFloat("Tornado X Min").Value = float.NegativeInfinity;
			fsm.FsmVariables.FindFsmFloat("Tornado X Max").Value = float.PositiveInfinity;
			fsm.FsmVariables.FindFsmFloat("Centre X").Value = Extensions.GetPositionX(obj.transform);
			fsm.GetState("State").AddAction(delegate
			{
				fsm.SendEvent("REFIGHT");
			}, 0, everyFrame: false);
			fsm.GetState("Start Idle").AddAction(delegate
			{
				Rigidbody2D component = obj.GetComponent<Rigidbody2D>();
				component.gravityScale = 1f;
				component.bodyType = (RigidbodyType2D)0;
				((Renderer)obj.GetComponent<MeshRenderer>()).enabled = true;
				((Behaviour)obj.GetComponent<Collider2D>()).enabled = true;
				fsm.FsmVariables.FindFsmGameObject("Damage Collider").Value.SetActive(true);
			}, 0, everyFrame: false);
			fsm.GetState("Stun Start").DisableAction(2);
			fsm.FsmVariables.FindFsmGameObject("Flare Glitter").Value = flares;
			PlayMakerFSM val = FSMUtility.LocateMyFSM(flares, "Control");
			FsmFloat lowMin = val.FsmVariables.FindFsmFloat("Low Min Y");
			FsmFloat lowMax = val.FsmVariables.FindFsmFloat("Low Max Y");
			FsmFloat highMin = val.FsmVariables.FindFsmFloat("High Min Y");
			FsmFloat highMax = val.FsmVariables.FindFsmFloat("High Max Y");
			FsmFloat posY = val.FsmVariables.FindFsmFloat("Pos Y");
			FsmFloat topY = val.FsmVariables.FindFsmFloat("Top Y");
			Vector3 flareOffset = new Vector3(73.8811f, 16.7204f, 0.0065f);
			fsm.GetState("Flash Antic").AddAction(delegate
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				flares.transform.position = obj.transform.position - flareOffset;
			}, 0, everyFrame: false);
			fsm.FsmVariables.FindFsmGameObject("Trapdoor Bursts").Value = bursts;
			fsm.GetState("BC Pause").AddAction(AdjustBursts, 0, everyFrame: false);
			FSMUtility.LocateMyFSM(bursts, "Control").FsmVariables.FindFsmGameObject("Trobbio").Value = obj;
			FsmState state2 = fsm.GetState("Exit 1");
			FsmFloat exitFloorPos = ((SetPosition)fsm.GetState("Exit Pause").actions[2]).y;
			state2.AddAction(AdjustFloor, 0, everyFrame: false);
			for (int i = 0; i < floor.transform.childCount; i++)
			{
				GameObject floorPiece = ((Component)floor.transform.GetChild(i)).gameObject;
				PlayMakerFSM floorFsm = FSMUtility.LocateMyFSM(floorPiece, "Control");
				FsmState state3 = floorFsm.GetState("Idle");
				state3.DisableAction(1);
				bool bumped = true;
				state3.AddAction(delegate
				{
					if (Mathf.Abs(Extensions.GetPositionX(obj.transform) - Extensions.GetPositionX(floorPiece.transform)) < 0.77095f)
					{
						if (!bumped)
						{
							floorFsm.SendEvent("BUMP");
							bumped = true;
						}
					}
					else
					{
						bumped = false;
					}
				}, -1, everyFrame: true);
			}
			floor.SetActive(false);
			fsm.GetState("Bomb Flurry?").AddAction(delegate
			{
				floor.SetActive(true);
			}, 0, everyFrame: false);
			fsm.GetState("Enter 1").AddAction(delegate
			{
				floor.SetActive(false);
			}, 0, everyFrame: false);
			FloatCompare val2 = (FloatCompare)fsm.GetState("Move Dir").actions[0];
			val2.equal = val2.lessThan;
			FloatCompare val3 = (FloatCompare)fsm.GetState("Move Dir 2").actions[0];
			val3.equal = val3.lessThan;
			FsmFloat floorY = fsm.FsmVariables.FindFsmFloat("Floor Y");
			FsmFloat ceilY = fsm.FsmVariables.FindFsmFloat("Max Y");
			fsm.GetState("Choice").AddAction(AdjustHeightFromSelf, 0, everyFrame: false);
			fsm.GetState("Enter Pause").AddAction(AdjustHeightAboveSelf, 0, everyFrame: false);
			state2.AddAction(AdjustHeightFromSelf, 0, everyFrame: false);
			RandomFloat entryRf = (RandomFloat)fsm.GetState("Get Entry Point").actions[0];
			fsm.GetState("Get Entry Point").AddAction(delegate
			{
				float positionX = Extensions.GetPositionX(obj.transform);
				float positionX2 = Extensions.GetPositionX(HeroController.instance.transform);
				entryRf.min = FsmFloat.op_Implicit(Mathf.Max(positionX2, positionX) - 12.4f);
				entryRf.max = FsmFloat.op_Implicit(Mathf.Min(positionX2, positionX) + 12.4f);
			}, 0, everyFrame: false);
			AdjustHeightFromSelf();
			AdjustBursts();
			AdjustFloor();
			return fsm;
			void AdjustBursts()
			{
				//IL_0053: 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_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_0082: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetPositionX(bursts.transform, Extensions.GetPositionX(obj.transform) - flareOffset.x);
				Vector2 val5 = default(Vector2);
				for (int k = 0; k < bursts.transform.GetChild(0).childCount; k++)
				{
					Transform child2 = bursts.transform.GetChild(0).GetChild(k);
					if (HeroController.instance.TryFindGroundPoint(ref val5, Vector2.op_Implicit(child2.position + new Vector3(0f, 5f)), true))
					{
						Extensions.SetPositionY(((Component)child2).transform, val5.y - 1.78f);
					}
				}
			}
			void AdjustFloor()
			{
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetPositionX(floor.transform, Extensions.GetPositionX(obj.transform) - flareOffset.x);
				Vector2 val4 = default(Vector2);
				for (int j = 0; j < floor.transform.childCount; j++)
				{
					Transform child = floor.transform.GetChild(j);
					if (HeroController.instance.TryFindGroundPoint(ref val4, Vector2.op_Implicit(obj.transform.position + new Vector3(0f, 5f)), true))
					{
						Extensions.SetPositionY(((Component)child).transform, val4.y - 1.2f);
					}
				}
			}
			void AdjustHeight(float f)
			{
				float num = HeroController.instance.FindGroundPointY(Extensions.GetPositionX(obj.transform), Extensions.GetPositionY(obj.transform) + f, false);
				lowMin.Value = num + 1.46f;
				lowMax.Value = num + 2.46f;
				highMin.Value = num + 6.96f;
				FsmFloat obj2 = topY;
				float value = (highMax.Value = num + 9.46f);
				obj2.Value = value;
				posY.Value = num + 1.7f;
				floorY.Value = num + 1.8f;
				ceilY.Value = num + 11.37f;
				exitFloorPos.Value = num - 3.04f;
				yPos?.Invoke(num, fsm);
			}
			void AdjustHeightAboveSelf()
			{
				AdjustHeight(6.5f);
			}
			void AdjustHeightFromSelf()
			{
				AdjustHeight(2f);
			}
		}

		public static void FixFourthChorusPreload(GameObject obj)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			Transform val = obj.transform.Find("song_golem");
			val.position = Vector3.zero;
			((Component)val).gameObject.SetActive(true);
			GameObject gameObject = ((Component)val.Find("Song_Butt").Find("SG_waist").Find("Torso")
				.Find("SG_head")).gameObject;
			gameObject.AddComponent<PlaceableObject.SpriteSource>();
			FourthChorus fourthChorus = obj.AddComponent<FourthChorus>();
			fourthChorus.parent = obj;
			fourthChorus.head = gameObject;
		}

		public static void FixFourthChorus(GameObject obj)
		{
			//IL_00ce: 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)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)obj.transform.GetChild(0)).gameObject, "Control");
			FourthChorus fc = obj.GetComponent<FourthChorus>();
			PersistentBoolItem item = obj.AddComponent<PersistentBoolItem>();
			((PersistentItem<bool>)(object)item).OnSetSaveState += delegate(bool b)
			{
				fc.head.GetComponent<HealthManager>().isDead = b;
				if (b)
				{
					obj.SetActive(false);
					item.SetValueOverride(true);
				}
			};
			((PersistentItem<bool>)(object)item).OnGetSaveState += delegate(out bool b)
			{
				b = fc.head.GetComponent<HealthManager>().isDead;
			};
			GameObject val = Object.Instantiate<GameObject>(_lavaRocks, obj.transform);
			((Object)val).name = ((Object)obj).name + " Lava Rocks";
			Transform transform = val.transform;
			Vector3 position = fc.head.transform.position;
			float? num = Extensions.GetPositionZ(val.transform);
			transform.position = Extensions.Where(position, (float?)null, (float?)null, num) - new Vector3(80.9f, 8.8f);
			val.SetActive(true);
			fsm.FsmVariables.FindFsmGameObject("Rocks L").Value = ((Component)val.transform.Find("Rocks L")).gameObject;
			fsm.FsmVariables.FindFsmGameObject("Rocks M").Value = ((Component)val.transform.Find("Rocks M")).gameObject;
			fsm.FsmVariables.FindFsmGameObject("Rocks R").Value = ((Component)val.transform.Find("Rocks R")).gameObject;
			BlackThreader.BlackThreadData blackThreadData = fc.head.AddComponent<BlackThreader.BlackThreadData>();
			PlayMakerFSM headFsm = FSMUtility.LocateMyFSM(fc.head, "Phase Control");
			blackThreadData.SingCheck = () => headFsm.ActiveStateName.Contains("Phase");
			blackThreadData.OnBlackThread = delegate
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				DamageHero[] componentsInChildren = obj.GetComponentsInChildren<DamageHero>(true);
				foreach (DamageHero val4 in componentsInChildren)
				{
					val4.damagePropertyFlags = (DamagePropertyFlags)(val4.damagePropertyFlags | 8);
				}
			};
			GameObject val2 = Object.Instantiate<GameObject>(_lavaPlats, obj.transform);
			((Object)val2).name = ((Object)obj).name + " Lava Plats";
			Transform transform2 = val2.transform;
			Vector3 position2 = fc.head.transform.position;
			num = Extensions.GetPositionZ(val2.transform);
			transform2.position = Extensions.Where(position2, (float?)null, (float?)null, num) + new Vector3(4.32f, -5.4f);
			fsm.FsmVariables.FindFsmGameObject("Lava Plats").Value = val2;
			val2.SetActive(true);
			fc.plats = val2;
			FsmState state = fsm.GetState("Death Start");
			state.DisableAction(0);
			state.DisableAction(1);
			FsmState state2 = fsm.GetState("Init");
			state2.DisableAction(17);
			state2.DisableAction(26);
			state2.DisableAction(27);
			state2.DisableAction(28);
			fsm.GetState("Meet?").AddAction(delegate
			{
				fsm.SendEvent("REMEET");
			}, 0, everyFrame: false);
			fsm.GetState("Clamp Roar?").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Music").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Punch").DisableAction(1);
			fsm.GetState("Punch Antic").DisableAction(4);
			fsm.GetState("Swipe L").DisableAction(5);
			fsm.GetState("Swipe R").DisableAction(5);
			fsm.GetState("Remeet Roar").DisableAction(9);
			FsmState state3 = fsm.GetState("Roar No Clamp");
			state3.DisableAction(0);
			((StartRoarEmitter)state3.actions[12]).stunHero = FsmBool.op_Implicit(false);
			state3.AddAction(delegate
			{
				obj.BroadcastEvent("OnRoar");
			}, 13, everyFrame: false);
			Fix("To HandSlam Antic", 2);
			Fix("Remeet Roar", 10);
			Fix("Punch Antic", 5);
			Fix("Stun Anim", 1);
			Fix("Death Anim", 1);
			FixB("Slam M", 2);
			FixB("Slam M", 5);
			FixB("Slam MR", 1);
			FixB("Slam ML", 1);
			FixB("Slam R", 1);
			FixB("Slam L", 1);
			void Fix(string stateName, int index)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Expected O, but got Unknown
				//IL_002a: 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_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				AnimatePositionTo val3 = (AnimatePositionTo)fsm.GetState(stateName).actions[index];
				val3.localSpace = true;
				FsmVector3 toValue = val3.toValue;
				toValue.value -= new Vector3(80.9f, 8.8f);
			}
			void FixB(string stateName, int index)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
				FsmVector3 vector3Value = ((SetVector3Value)fsm.GetState(stateName).actions[index]).vector3Value;
				vector3Value.value -= new Vector3(80.9f, 8.8f);
			}
		}

		public static void FixShakra(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			Object.Destroy((Object)(object)FSMUtility.LocateMyFSM(obj, "Dialogue"));
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Attack Enemies");
			fsm.fsmTemplate = null;
			fsm.GetState("Idle").AddAction(delegate
			{
				fsm.SendEvent("BATTLE HERO");
			}, 0, everyFrame: false);
			fsm.GetState("Start Music?").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.fsm.globalTransitions = fsm.fsm.globalTransitions.Where((FsmTransition o) => o.EventName != "START AWAY").ToArray();
			FsmState state = fsm.GetState("Look Pos");
			state.DisableAction(0);
			state.DisableAction(1);
			FsmState state2 = fsm.GetState("Look R");
			state2.DisableAction(2);
			state2.DisableAction(3);
			FsmState state3 = fsm.GetState("Look L");
			state3.DisableAction(2);
			state3.DisableAction(3);
			FsmState state4 = fsm.GetState("Do Y");
			state4.DisableAction(2);
			state4.DisableAction(3);
			FsmState state5 = fsm.GetState("Try Stomp");
			state5.DisableAction(5);
			state5.DisableAction(6);
			state5.DisableAction(9);
			state5.DisableAction(10);
			FsmState state6 = fsm.GetState("Destination Retry");
			state6.DisableAction(2);
			FsmState state7 = fsm.GetState("Charge Side");
			state7.DisableAction(0);
			state7.DisableAction(1);
			FsmState state8 = fsm.GetState("Tele In");
			state8.transitions = state8.transitions.Where((FsmTransition o) => o.EventName != "UNALERT").ToArray();
			FsmState state9 = fsm.GetState("Charge Tele In");
			state9.DisableAction(3);
			FsmFloat chargeY = fsm.FsmVariables.FindFsmFloat("Charge Y");
			state9.AddAction(delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				float num = HeroController.instance.FindGroundPointY(HeroController.instance.transform.position.x, HeroController.instance.transform.position.y + 0.5f, true);
				chargeY.Value = num + 0.717f;
			}, 6, everyFrame: false);
			fsm.GetState("End Battle").AddAction(delegate
			{
				Object.Destroy((Object)(object)obj);
			}, -1, everyFrame: false);
		}

		public static void FixBellBeast(GameObject obj)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			float cx = Extensions.GetPositionX(obj.transform);
			float cy = Extensions.GetPositionY(obj.transform);
			RaycastHit2D val = Physics2D.Raycast(Vector2.op_Implicit(obj.transform.position), Vector2.right, 10.35f, TerrainMask);
			RaycastHit2D val2 = Physics2D.Raycast(Vector2.op_Implicit(obj.transform.position), Vector2.left, 10.35f, TerrainMask);
			fsm.FsmVariables.FindFsmFloat("Centre X").Value = cx;
			FsmFloat val3 = fsm.FsmVariables.FindFsmFloat("Left X");
			FsmFloat val4 = fsm.FsmVariables.FindFsmFloat("Right X");
			if (RaycastHit2D.op_Implicit(val))
			{
				val4.Value = ((RaycastHit2D)(ref val)).point.x - 1f;
			}
			else
			{
				val4.Value = cx + 10.35f;
			}
			if (RaycastHit2D.op_Implicit(val2))
			{
				val3.Value = ((RaycastHit2D)(ref val2)).point.x + 1f;
			}
			else
			{
				val3.Value = cx - 10.35f;
			}
			FsmFloat groundY = fsm.FsmVariables.FindFsmFloat("Ground Y");
			FsmFloat leapOutY = fsm.FsmVariables.FindFsmFloat("LeapOut Y");
			FsmFloat submergeY = fsm.FsmVariables.FindFsmFloat("Submerge Y");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, -1, everyFrame: false);
			fsm.GetState("Burst Pos").AddAction(delegate
			{
				UpdatePositions(cx, cy);
			}, 0, everyFrame: false);
			fsm.GetState("Rage Antic").AddAction(delegate
			{
				UpdatePositions(cx, cy);
			}, 0, everyFrame: false);
			UpdatePositions(cx, cy);
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			GameObject corpse = component.GetInstantiatedCorpse((AttackTypes)1);
			RemoveConstrainPosition(corpse);
			PlayMakerFSM fsm2 = FSMUtility.LocateMyFSM(corpse, "Death");
			fsm2.GetState("Stagger").DisableAction(2);
			fsm2.GetState("Blow").DisableAction(4);
			fsm2.GetState("End Pause").AddAction(delegate
			{
				Object.Destroy((Object)(object)corpse);
			}, -1, everyFrame: false);
			void UpdatePositions(float xPos, float yPos)
			{
				float num = HeroController.instance.FindGroundPointY(xPos, yPos + 1f, true) + 1.83f;
				groundY.Value = num;
				leapOutY.Value = num - 11.52f;
				submergeY.Value = num - 18f;
			}
		}

		public static void FixGrom(GameObject obj)
		{
			//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_00d8: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			Vector3 startPos = obj.transform.position;
			fsm.GetState("Dormant").AddAction(delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				obj.transform.position = startPos;
				fsm.SendEvent("SPAWN");
			}, -1, everyFrame: false);
			fsm.GetState("Position").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			FsmFloat groundY = fsm.FsmVariables.FindFsmFloat("Ground Y");
			fsm.GetState("Drop").AddAction(delegate
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				float value = HeroController.instance.FindGroundPointY(obj.transform.position.x, obj.transform.position.y + 1f, true);
				groundY.Value = value;
			}, 2, everyFrame: true);
			((AddHP)fsm.GetState("Heal").actions[0]).healToMax = FsmBool.op_Implicit(true);
		}

		public static void FixWidow(GameObject obj)
		{
			Rigidbody2D component = obj.GetComponent<Rigidbody2D>();
			component.bodyType = (RigidbodyType2D)0;
			component.gravityScale = 0f;
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, -1, everyFrame: false);
			fsm.GetState("Set Intro Pos").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
		}

		public static void FixSquirm(GameObject obj)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_squirmArea, obj.transform);
			GameObject val2 = Object.Instantiate<GameObject>(_squirmSingArea, obj.transform);
			val.transform.localPosition = Vector3.zero;
			val2.transform.localPosition = Vector3.zero;
			PlayMakerFSM val3 = obj.AddComponent<PlayMakerFSM>();
			val3.fsm = Fsm.NewTempFsm();
			val3.fsm.states = Array.Empty<FsmState>();
			val3.AddState("Idle");
			val3.fsm.startState = "Idle";
			RangeAttacker component = obj.GetComponent<RangeAttacker>();
			component.appearChance = 1f;
			component.trigger = val.GetComponent<TrackTriggerObjects>();
			component.singRange = val2.GetComponent<TrackTriggerObjects>();
			val.RemoveComponent<Collider2D>();
			val2.RemoveComponent<Collider2D>();
			Squirm squirm = obj.AddComponent<Squirm>();
			CircleCollider2D val4 = val.AddComponent<CircleCollider2D>();
			((Collider2D)val4).isTrigger = true;
			squirm.hideRange = val4;
			CircleCollider2D val5 = val2.AddComponent<CircleCollider2D>();
			((Collider2D)val5).isTrigger = true;
			squirm.musicRange = val5;
		}

		public static void FixGrandReed(GameObject obj)
		{
			obj.AddComponent<GrandReed>();
		}

		public static void FixPendra(GameObject obj)
		{
			obj.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			obj.AddComponent<TweenFixer>();
			BoxCollider2D[] componentsInChildren = obj.GetComponentsInChildren<BoxCollider2D>(true);
			foreach (BoxCollider2D val in componentsInChildren)
			{
				((Collider2D)val).isTrigger = false;
			}
		}

		public static void FixCogworker(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Batlle Ready").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, 0, everyFrame: false);
			fsm.GetState("Translate Back").DisableAction(0);
			fsm.GetState("Fly In").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
		}

		public static void FixSlubberlug(GameObject obj)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Death Air").DisableAction(5);
			Vector3 pos = obj.transform.position;
			bool died = false;
			fsm.GetState("Death Air").AddAction(delegate
			{
				died = true;
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Dormant");
			state.AddAction(delegate
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				if (died)
				{
					Object.Destroy((Object)(object)obj);
				}
				((Component)obj.transform.GetChild(3)).gameObject.SetActive(true);
				obj.transform.position = pos;
				fsm.SendEvent("SPAWN");
			}, -1, everyFrame: false);
			fsm.GetState("Home Dir").AddAction(delegate
			{
				fsm.SendEvent((Random.value > 0.5f) ? "L" : "R");
			}, -1, everyFrame: false);
		}

		public static void FixLace1(GameObject obj)
		{
			RemoveConstrainPosition(obj);
			obj.AddComponent<Lace>();
			Rigidbody2D rb2d = obj.GetComponent<Rigidbody2D>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Encountered?").AddAction(delegate
			{
				fsm.SendEvent("REFIGHT");
			}, 0, everyFrame: false);
			fsm.GetState("Dormant").AddAction(delegate
			{
				rb2d.linearVelocityY = 0f;
			}, 0, everyFrame: false);
			EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
			component.PreInstantiate();
			RemoveConstrainPosition(component.GetInstantiatedCorpse((AttackTypes)1));
		}

		public static void FixUnravelled(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			obj.AddComponent<Unravelled>().fsm = val;
			GameObject val2 = Object.Instantiate<GameObject>(_attackSpears);
			((Object)val2).name = ((Object)obj).name + " Attack Spears";
			val.FsmVariables.FindFsmGameObject("Attack Spears").Value = val2;
			GameObject val3 = Object.Instantiate<GameObject>(_corpseProjectiles);
			((Object)val3).name = ((Object)obj).name + " Corpse Projectiles";
			val.FsmVariables.FindFsmGameObject("Corpse Projectiles").Value = val3;
		}
	}
	public static class HazardFixers
	{
		public class JunkPipe : MonoBehaviour
		{
			private PlayMakerFSM _fsm;

			private void Awake()
			{
				_fsm = ((Component)this).GetComponent<PlayMakerFSM>();
				_fsm.GetState("Pause").DisableAction(2);
				_fsm.GetState("Flow").AddAction(delegate
				{
					((Component)((Component)this).transform.GetChild(2)).gameObject.SetActive(true);
				}, -1, everyFrame: false);
			}

			private void OnDisable()
			{
				((Component)((Component)this).transform.GetChild(2)).gameObject.SetActive(false);
			}

			private void OnEnable()
			{
				((Component)((Component)this).transform.GetChild(2)).gameObject.SetActive(false);
			}
		}

		private class MaggotBlob : MonoBehaviour
		{
			private bool _setup;

			private void Update()
			{
				if (!_setup)
				{
					_setup = true;
					PlayMakerFSM val = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
					val.SendEvent("FINISHED");
					FsmState state = val.GetState("Launch");
					state.DisableAction(4);
					state.DisableAction(7);
					state.DisableAction(8);
				}
			}
		}

		public class Flintbomb : MonoBehaviour
		{
			private MeshRenderer _renderer;

			private void Start()
			{
				_renderer = ((Component)this).GetComponent<MeshRenderer>();
			}

			private void Update()
			{
				if (!((Renderer)_renderer).enabled)
				{
					((Behaviour)this).enabled = false;
					((Component)this).gameObject.BroadcastEvent("OnExplode");
				}
			}
		}

		private static GameObject _cogDamager;

		private static GameObject _junkFall;

		private static GameObject _lavaBox;

		private static GameObject _coalRegion;

		private static GameObject _tendrilDamager;

		private static PlayMakerFSM _carverDamagerFsm;

		private static GameObject _cradleSpikes;

		private static GameObject _voltHazard;

		private static float _lanternTime = 1f;

		private static GameObject _currentTendrilDamager;

		private static readonly LayerMask HeroBoxMask = LayerMask.op_Implicit(LayerMask.GetMask(new string[1] { "Hero Box" }));

		public static void Init()
		{
			PreloadManager.RegisterPreload(new BasicPreload("Cog_04", "Spike Cog collider Round/Cog Damager", delegate(GameObject o)
			{
				CogMultiHitter componentInChildren = o.GetComponentInChildren<CogMultiHitter>();
				componentInChildren.useSelfForAngle = true;
				_cogDamager = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Under_06", "junk_chute_ manual (1)", delegate(GameObject o)
			{
				_junkFall = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Bone_East_09", "Lava Box", delegate(GameObject o)
			{
				_lavaBox = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Abyss_07", "Abyss Tendril Hero Damager", delegate(GameObject o)
			{
				_tendrilDamager = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Coral_11", "Sand Centipede Hero Damager", delegate(GameObject o)
			{
				GameObject val5 = Object.Instantiate<GameObject>(o);
				val5.SetActive(true);
				val5.RemoveComponent<EventRegister>();
				Object.DontDestroyOnLoad((Object)(object)val5);
				_carverDamagerFsm = FSMUtility.LocateMyFSM(val5, "Control");
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Bone_East_03", "Coal Region", delegate(GameObject o)
			{
				_coalRegion = o;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Cradle_03", "cradle_spike_plat (10)", delegate(GameObject o)
			{
				_cradleSpikes = ((Component)o.transform.GetChild(8)).gameObject;
			}));
			PreloadManager.RegisterPreload(new BasicPreload("Coral_29", "Zap Hazard Parent", delegate(GameObject o)
			{
				bool flag = false;
				PolygonCollider2D[] componentsInChildren = o.GetComponentsInChildren<PolygonCollider2D>();
				foreach (PolygonCollider2D val4 in componentsInChildren)
				{
					if (!flag)
					{
						flag = true;
					}
					else
					{
						Object.Destroy((Object)(object)((Component)val4).gameObject);
					}
				}
				_voltHazard = o;
			}));
			HookUtils.OnFsmAwake = (Action<PlayMakerFSM>)Delegate.Combine(HookUtils.OnFsmAwake, (Action<PlayMakerFSM>)delegate(PlayMakerFSM fsm)
			{
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Expected O, but got Unknown
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Expected O, but got Unknown
				if (fsm.FsmName == "Control" && ((Object)((Component)fsm).gameObject).name.Contains("Wisp Fireball"))
				{
					FsmGameObject val = fsm.FsmVariables.FindFsmGameObject("Wisp Fireball Master");
					if (val != null)
					{
						val.Value = null;
						fsm.GetState("Request Attack").AddAction(delegate
						{
							if (_lanternTime <= 0f)
							{
								_lanternTime = 1f;
								fsm.SendEvent("APPROVED");
							}
						}, 2, everyFrame: false);
					}
				}
				else if (((Object)fsm).name.Contains("Trobbio Bomb"))
				{
					FsmState state = fsm.GetState("Air");
					BoolAllTrue val2 = (BoolAllTrue)state.actions[13];
					val2.boolVariables = (FsmBool[])(object)new FsmBool[1] { val2.boolVariables[2] };
					fsm.GetState("Antic").DisableAction(13);
				}
				else if (((Object)fsm).name.Contains("Trobbio Cross Bomb"))
				{
					FsmState state2 = fsm.GetState("Air");
					BoolAllTrue val3 = (BoolAllTrue)state2.actions[18];
					val3.boolVariables = (FsmBool[])(object)new FsmBool[1] { val3.boolVariables[2] };
				}
			});
		}

		public static void UpdateLanterns()
		{
			_lanternTime -= Time.deltaTime;
		}

		public static void FixFan(GameObject fan)
		{
			Transform transform = fan.transform;
			((Component)transform.GetChild(0)).gameObject.SetActive(false);
			((Component)transform.GetChild(1)).gameObject.SetActive(false);
			((Component)transform.GetChild(3).GetChild(2)).gameObject.SetActive(false);
			((Component)transform.GetChild(4)).gameObject.SetActive(false);
		}

		public static void FixLargeCog(GameObject cog)
		{
			Extensions.SetPositionZ(cog.transform, 0.01f);
		}

		public static void FixLargeCogAfterSpawn(GameObject cog)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_cogDamager, (Transform)null);
			val.transform.parent = cog.transform;
			CogMultiHitter component = val.GetComponent<CogMultiHitter>();
			component.heroGrindEffect = Object.Instantiate<GameObject>(((Component)component.heroGrindEffect).gameObject, val.transform).transform;
			component.heroGrindEffect.parent = null;
			component.heroGrindEffect.localScale = Vector3.one;
			val.transform.localPosition = Vector3.zero;
			val.SetActive(true);
		}

		public static void FixUnderworksCog(GameObject cog)
		{
			Extensions.SetPositionZ(cog.transform, 0.01f);
		}

		public static void FixCog(GameObject cog)
		{
			cog.RemoveComponent<CurveOffsetAnimation>();
			cog.transform.GetChild(3).SetAsFirstSibling();
		}

		public static void FixMillTrap(GameObject obj)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			((Component)obj.transform.GetChild(0)).gameObject.SetActive(false);
			Transform transform = obj.transform;
			transform.localScale *= 2f;
		}

		public static void FixZaprock(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Idle").AddAction(delegate
			{
				fsm.SendEvent("ENTER");
			}, 0, everyFrame: false);
		}

		public static void FixWispLantern(GameObject obj)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			obj.GetComponentInChildren<Rigidbody2D>().constraints = (RigidbodyConstraints2D)7;
			ConstraintSource val = default(ConstraintSource);
			((ConstraintSource)(ref val)).sourceTransform = obj.transform.GetChild(3).GetChild(0);
			((ConstraintSource)(ref val)).weight = 1f;
			ConstraintSource source = val;
			AddConstraint(1);
			AddConstraint(2);
			AddConstraint(4);
			AddConstraint(5);
			void AddConstraint(int num)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				PositionConstraint val2 = ((Component)obj.transform.GetChild(num)).gameObject.AddComponent<PositionConstraint>();
				val2.AddSource(source);
				val2.constraintActive = true;
			}
		}

		public static void FixWisp(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmGameObject master = fsm.FsmVariables.FindFsmGameObject("Wisp Fireball Master");
			fsm.GetState("Request Attack").AddAction(delegate
			{
				if (!Object.op_Implicit((Object)(object)master.Value) && _lanternTime <= 0f)
				{
					_lanternTime = 1f;
					fsm.SendEvent("APPROVED");
				}
			}, 2, everyFrame: false);
			fsm.GetState("Follow Start").DisableAction(1);
		}

		public static void FixSpikeBall(GameObject obj)
		{
			obj.transform.GetChild(1).SetAsFirstSibling();
		}

		public static void FixCoralSpike(GameObject obj)
		{
			bool beenDormant = false;
			FSMUtility.LocateMyFSM(obj, "Control").GetState("Dormant").AddAction(delegate
			{
				if (!beenDormant)
				{
					beenDormant = true;
				}
				else
				{
					obj.BroadcastEvent("OnBreak");
				}
			}, 0, everyFrame: false);
		}

		public static void FixJunkPipe(GameObject obj)
		{
			obj.transform.GetChild(2).SetAsFirstSibling();
		}

		public static void FixJunkPipePostSpawn(GameObject obj)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_junkFall, (Transform)null);
			val.transform.parent = obj.transform;
			Extensions.SetLocalPosition2D(val.transform, new Vector2(2.5f, -6.5f));
			val.SetActive(true);
			((Behaviour)FSMUtility.LocateMyFSM(((Component)val.transform.Find("Spike Collider")).gameObject, "Shift Hero")).enabled = false;
			val.AddComponent<JunkPipe>();
		}

		public static void FixMaggotBlob(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.InitTemplate();
			val.fsmTemplate = null;
			obj.AddComponent<MaggotBlob>();
			obj.RemoveComponent<RandomScale>();
		}

		public static void FixLava(GameObject obj)
		{
			//IL_0020: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_lavaBox, obj.transform);
			val.SetActive(true);
			val.transform.localPosition = Vector3.zero;
			val.transform.localScale = Vector3.one;
			BoxCollider2D component = val.GetComponent<BoxCollider2D>();
			component.size = Vector2.one;
			((Collider2D)component).offset = Vector2.zero;
		}

		public static void FixCoal(GameObject obj)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_coalRegion, obj.transform);
			val.SetActive(true);
			val.transform.localPosition = Vector3.zero;
			BoxCollider2D component = val.GetComponent<BoxCollider2D>();
			component.size = new Vector2(2.75f, 1f);
			((Collider2D)component).offset = new Vector2(0f, 0.25f);
		}

		public static void FixVoltgrass(GameObject obj)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_voltHazard, obj.transform);
			val.SetActive(true);
			val.transform.localPosition = Vector3.zero;
			PolygonCollider2D componentInChildren = val.GetComponentInChildren<PolygonCollider2D>();
			componentInChildren.points = (Vector2[])(object)new Vector2[6]
			{
				new Vector2(-1f, -3f),
				new Vector2(1f, -4f),
				new Vector2(2.2f, -4f),
				new Vector2(3f, 0.4f),
				new Vector2(2f, 1f),
				new Vector2(-0.6f, 1f)
			};
			((Component)componentInChildren).transform.GetChild(0).localPosition = new Vector3(0.6198f, -1.1504f, 0f);
			((Component)componentInChildren).transform.localPosition = Vector3.zero;
		}

		public static void FixTendrils(GameObject obj)
		{
			if (!Object.op_Implicit((Object)(object)_currentTendrilDamager))
			{
				_currentTendrilDamager = Object.Instantiate<GameObject>(_tendrilDamager, obj.transform);
				((Object)_currentTendrilDamager).name = "[Architect] " + ((Object)_currentTendrilDamager).name;
				_currentTendrilDamager.SetActive(true);
			}
		}

		public static void FixCarvers(GameObject obj)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!EditManager.IsEditing)
			{
				TriggerEnterEvent componentInChildren = obj.GetComponentInChildren<TriggerEnterEvent>();
				componentInChildren.checkLayer = HeroBoxMask;
				componentInChildren.fsmTarget = _carverDamagerFsm;
				componentInChildren.fsmEvent = "CENTIPEDE DAMAGE";
			}
		}

		public static void FixCradleSpikes(GameObject obj)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Object.Instantiate<GameObject>(_cradleSpikes, obj.transform.position, default(Quaternion), obj.transform).GetComponent<TinkEffect>().overrideCamShake = true;
		}

		public static void FixTrobbioBomb(GameObject obj)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, -1, everyFrame: false);
			fsm.GetState("Fling").DisableAction(0);
			FsmState state = fsm.GetState("Air");
			state.DisableAction(15);
			BoolAllTrue val = (BoolAllTrue)state.actions[13];
			val.boolVariables = (FsmBool[])(object)new FsmBool[1] { val.boolVariables[2] };
			fsm.GetState("Antic").DisableAction(13);
		}

		public static void FixTrobbioCrossBomb(GameObject obj)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, -1, everyFrame: false);
			fsm.GetState("Fling").DisableAction(0);
			FsmState state = fsm.GetState("Air");
			state.DisableAction(11);
			BoolAllTrue val = (BoolAllTrue)state.actions[18];
			val.boolVariables = (FsmBool[])(object)new FsmBool[1] { val.boolVariables[2] };
			fsm.GetState("Antic").DisableAction(7);
		}

		public static void FixFlintbomb(GameObject obj)
		{
			obj.AddComponent<Flintbomb>();
		}

		public static void FixCoralCrust(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			((PersistentItem<bool>)(object)obj.GetComponent<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
			{
				if (value)
				{
					obj.BroadcastEvent("LoadedBroken");
				}
			};
			fsm.GetState("Fully Broken").AddAction(delegate
			{
				obj.BroadcastEvent("OnBreak");
				obj.BroadcastEvent("FirstBreak");
			}, -1, everyFrame: false);
		}
	}
	public static class InteractableFixers
	{
		private class CoralNut : MonoBehaviour
		{
			private void OnEnable()
			{
				((Behaviour)((Component)this).GetComponent<CircleCollider2D>()).enabled = true;
			}
		}

		public class DialDoor : MonoBehaviour
		{
			public float rot;

			private bool _started;

			private void Update()
			{
				if (!_started)
				{
					_started = true;
					((Component)this).GetComponent<DialDoorBridge>().SetInitialRotation(rot % 180f != 0f);
				}
			}
		}

		public class BindSource : MonoBehaviour
		{
			public string sceneId = "Tut_01";

			public string doorId = "top1";

			public int bindCount = 3;

			public PlayMakerFSM fsm;

			public void Start()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				BeginSceneTransition val = (BeginSceneTransition)fsm.GetState("Reload Scene").actions[3];
				val.sceneName = FsmString.op_Implicit(sceneId);
				val.entryGateName = FsmString.op_Implicit(doorId);
				fsm.FsmVariables.FindFsmInt("Binds").Value = bindCount;
			}
		}

		public class BindSourceStand : MiscFixers.Npc
		{
			public PlayMakerFSM fsm;

			public void Start()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				RunDialogue val = (RunDialogue)fsm.GetState("Weaver Dialogue").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("Dialogue End").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinishTalk");
				}, 0, everyFrame: false);
			}
		}

		public class BoneCarriage : MonoBehaviour
		{
			public Vector3 leftOffset;

			public Vector3 rightOffset;

			public void Start()
			{
				//IL_000f: 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_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: 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)
				ManualLift component = ((Component)this).GetComponent<ManualLift>();
				component.leftTargetPos = Vector2.op_Implicit(((Component)this).transform.position + leftOffset);
				component.rightTargetPos = Vector2.op_Implicit(((Component)this).transform.position + rightOffset);
			}
		}

		public static void Init()
		{
			typeof(AnimatorControlSequence).Hook("PlayAnimatorFromStart", (Action<Action<AnimatorControlSequence>, AnimatorControlSequence>)delegate(Action<AnimatorControlSequence> orig, AnimatorControlSequence self)
			{
				if (Object.op_Implicit((Object)(object)self.animator))
				{
					orig(self);
				}
			});
		}

		public static void FixMarchPlate(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = fsm.GetState("Activate Device");
			state.DisableAction(0);
			state.AddAction(delegate
			{
				obj.BroadcastEvent("OnActivate");
			}, 0, everyFrame: false);
		}

		public static void FixSlabPlate(GameObject obj)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			TrapPressurePlate component = obj.GetComponent<TrapPressurePlate>();
			component.OnPressed.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("OnActivate");
			});
		}

		public static void FixLever(GameObject obj)
		{
			((PersistentItem<bool>)(object)obj.GetComponent<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
			{
				if (value)
				{
					EventManager.BroadcastEvent(obj, "OnPull");
					EventManager.BroadcastEvent(obj, "LoadedPulled");
				}
			};
		}

		public static void FixTrapWire(GameObject obj)
		{
			FSMUtility.LocateMyFSM(obj, "Control").GetState("Snap").AddAction(delegate
			{
				obj.BroadcastEvent("OnActivate");
			}, 0, everyFrame: false);
		}

		public static void FixCogLever(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Activate").AddAction(delegate
			{
				obj.BroadcastEvent("OnPull");
				obj.BroadcastEvent("LoadedPulled");
			}, -1, everyFrame: false);
			fsm.GetState("Open Mechanism").AddAction(delegate
			{
				obj.BroadcastEvent("OnPull");
				obj.BroadcastEvent("FirstPulled");
			}, -1, everyFrame: false);
		}

		public static void FixReusableCogLever(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Hit").AddAction(delegate
			{
				obj.BroadcastEvent("OnActivate");
			}, -1, everyFrame: false);
		}

		public static void FixCogLeverPreload(GameObject obj)
		{
			obj.transform.GetChild(3).SetAsFirstSibling();
			((Component)obj.transform.GetChild(2)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(4)).gameObject.SetActive(false);
		}

		public static void FixButtonPreload(GameObject obj)
		{
			((Component)obj.transform.GetChild(0)).gameObject.SetActive(false);
		}

		public static void FixButton(GameObject obj)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			PersistentPressurePlate component = obj.GetComponent<PersistentPressurePlate>();
			component.OnActivate.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("OnPress");
				obj.BroadcastEvent("FirstPress");
			});
			component.OnActivated.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("OnPress");
				obj.BroadcastEvent("LoadedPressed");
			});
		}

		public static void FixCoralNut(GameObject obj)
		{
			obj.AddComponent<CoralNut>();
		}

		public static void FixActivator(GameObject obj)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			TimedActivator component = obj.GetComponent<TimedActivator>();
			component.OnActivated.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("OnActivate");
			});
			component.OnDeactivate.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("OnDeactivate");
			});
		}

		public static void FixReusableLever(GameObject obj)
		{
			FSMUtility.LocateMyFSM(obj, "Control Lever").GetState("Hit Effect").AddAction(delegate
			{
				obj.BroadcastEvent("OnActivate");
			}, 0, everyFrame: false);
		}

		public static void FixCloverStatue(GameObject obj)
		{
			FSMUtility.LocateMyFSM(obj, "Control").GetState("Break").AddAction(delegate
			{
				obj.BroadcastEvent("OnActivate");
			}, 0, everyFrame: false);
		}

		public static void FixSlabBlade(GameObject obj)
		{
			((Component)obj.transform.GetChild(2)).gameObject.SetActive(false);
		}

		public static void FixSpikeBall(GameObject obj)
		{
			obj.transform.GetChild(1).GetChild(1).SetAsFirstSibling();
		}

		public static void FixGong(GameObject obj)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			TinkEffect componentInChildren = obj.GetComponentInChildren<TinkEffect>();
			componentInChildren.OnTinked.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("OnActivate");
			});
			obj.GetComponentInChildren<Rigidbody2D>().constraints = (RigidbodyConstraints2D)7;
		}

		public static void FixSilkLever(GameObject obj)
		{
			Extensions.SetPositionZ(obj.transform, -0.15f);
			Extensions.SetRotation2D(obj.transform, 4.8057f);
			((Component)obj.transform.GetChild(0)).gameObject.SetActive(false);
		}

		public static void FixDialDoor(GameObject obj)
		{
			for (int i = 4; i <= 8; i++)
			{
				((Component)obj.transform.GetChild(i)).gameObject.SetActive(false);
			}
			obj.RemoveComponentsInChildren<CameraLockArea>();
		}

		public static void FixDialDoorRot(GameObject obj, float rot)
		{
			obj.AddComponent<DialDoor>().rot = rot;
		}

		public static void FixShakraPole(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = fsm.GetState("Idle");
			state.transitions = state.transitions.Where((FsmTransition o) => o.EventName == "HIT").ToArray();
			FsmState state2 = fsm.GetState("Hit");
			state2.transitions[0].toState = "Idle";
			state2.transitions[0].toFsmState = state;
			state2.AddAction(delegate
			{
				obj.BroadcastEvent("OnActivate");
			}, -1, everyFrame: false);
		}

		public static void FixSilkVinesPreload(GameObject obj)
		{
			obj.RemoveComponent<DeactivateIfPlayerdataTrue>();
			Extensions.SetPositionZ(obj.transform, 0f);
			((Component)obj.transform.GetChild(0)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(2).GetChild(0).GetChild(0)).gameObject.RemoveComponent<SilkPusher>();
			((Component)obj.transform.GetChild(2).GetChild(0).GetChild(0)).gameObject.RemoveComponent<PolygonCollider2D>();
			((Component)obj.transform.GetChild(2).GetChild(0)).gameObject.layer = LayerMask.NameToLayer("Terrain");
			((Collider2D)((Component)obj.transform.GetChild(2).GetChild(0)).GetComponent<PolygonCollider2D>()).isTrigger = false;
			((Component)obj.transform.GetChild(2).GetChild(0)).gameObject.AddComponent<SteepSlope>();
			for (int i = 1; i <= 4; i++)
			{
				((Component)obj.transform.GetChild(2).GetChild(i)).gameObject.SetActive(false);
			}
		}

		public static void FixSilkVines(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Destroy").AddAction(delegate
			{
				obj.BroadcastEvent("OnBreak");
				obj.BroadcastEvent("FirstBreak");
			}, 0, everyFrame: false);
			((PersistentItem<bool>)(object)obj.GetComponent<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
			{
				if (value)
				{
					EventManager.BroadcastEvent(obj, "OnBreak");
					EventManager.BroadcastEvent(obj, "LoadedBroken");
				}
			};
			PlayMakerFSM val = FSMUtility.LocateMyFSM(((Component)obj.transform.GetChild(2).GetChild(0)).gameObject, "thick_silk_vine");
			val.fsmTemplate = null;
			val.GetState("Hit Check").AddAction(delegate
			{
				obj.BroadcastEvent("OnHit");
			}, 0, everyFrame: false);
			PolygonCollider2D pc = ((Component)obj.transform.GetChild(2).GetChild(0)).GetComponent<PolygonCollider2D>();
			val.GetState("Break").AddAction(delegate
			{
				((Behaviour)pc).enabled = false;
				obj.BroadcastEvent("OnTempBreak");
			}, 0, everyFrame: false);
			val.GetState("Reform").AddAction(delegate
			{
				((Behaviour)pc).enabled = true;
			}, 0, everyFrame: false);
		}

		public static void FixExplodingWallPreload(GameObject obj)
		{
			((Component)obj.transform.Find("CamLock")).gameObject.SetActive(false);
			for (int i = 0; i <= 2; i++)
			{
				((Component)obj.transform.Find("wall2").GetChild(i)).gameObject.SetActive(false);
			}
			for (int j = 0; j <= 5; j++)
			{
				((Component)obj.transform.Find("wall3").GetChild(j)).gameObject.SetActive(false);
			}
		}

		public static void FixExplodingWall(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Set PD 2").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 1, everyFrame: false);
			fsm.GetState("Explode").AddAction(delegate
			{
				obj.BroadcastEvent("OnBreak");
				obj.BroadcastEvent("FirstBreak");
			}, 0, everyFrame: false);
			((PersistentItem<bool>)(object)obj.GetComponent<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
			{
				if (value)
				{
					EventManager.BroadcastEvent(obj, "OnBreak");
					EventManager.BroadcastEvent(obj, "LoadedBroken");
				}
			};
		}

		public static void FixFallingRock(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Explode").AddAction(delegate
			{
				obj.BroadcastEvent("OnBreak");
				obj.BroadcastEvent("FirstBreak");
			}, 0, everyFrame: false);
			((PersistentItem<bool>)(object)obj.GetComponent<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
			{
				if (value)
				{
					EventManager.BroadcastEvent(obj, "OnBreak");
					EventManager.BroadcastEvent(obj, "LoadedBroken");
				}
			};
		}

		public static void FixBindSource(GameObject obj)
		{
			//IL_007e: 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)
			((Component)obj.transform.GetChild(1)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(9)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(10)).gameObject.SetActive(false);
			BoxCollider2D component = obj.GetComponent<BoxCollider2D>();
			component.size = new Vector2(3f, 3f);
			((Collider2D)component).offset = Vector2.zero;
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Check Unlocked").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Crest Msg").DisableAction(2);
			fsm.fsm.globalTransitions = Array.Empty<FsmTransition>();
			fsm.GetState("Bind Burst").AddAction(delegate
			{
				obj.BroadcastEvent("OnBind");
			}, 0, everyFrame: false);
			fsm.GetState("Final Bind Burst").AddAction(delegate
			{
				obj.BroadcastEvent("OnFinalBind");
			}, 0, everyFrame: false);
			obj.AddComponent<BindSource>().fsm = fsm;
		}

		public static void FixBindSourceStand(GameObject obj)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			((Component)obj.transform.GetChild(7)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(8)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(16)).gameObject.SetActive(false);
			BoxCollider2D component = obj.GetComponent<BoxCollider2D>();
			component.size = new Vector2(3f, 3f);
			((Collider2D)component).offset = Vector2.zero;
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Inspection");
			fsm.GetState("Collected Check").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Msg Type?").AddAction(delegate
			{
				fsm.SendEvent("ITEM");
			}, 1, everyFrame: false);
			fsm.GetState("Item Msg").AddAction(delegate
			{
				fsm.SendEvent("GET ITEM MSG END");
			}, 0, everyFrame: false);
			fsm.GetState("Bind Burst").AddAction(delegate
			{
				obj.BroadcastEvent("OnFinalBind");
			}, 0, everyFrame: false);
			obj.AddComponent<BindSourceStand>().fsm = fsm;
		}

		public static void FixBoneCarriage(GameObject obj)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 1; i <= 10; i++)
			{
				((Component)obj.transform.GetChild(i)).gameObject.SetActive(false);
			}
			Transform child = obj.transform.GetChild(0);
			child.localPosition = Vector3.zero;
			Extensions.SetPositionZ(child, -0.03f);
			((Component)child).gameObject.AddComponent<BoneCarriage>();
		}
	}
	public class InverseHeroTreadmill : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <NeedleControlRoutine>d__45 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public InverseHeroTreadmill <>4__this;

			private float <needleT>5__1;

			private float <needleSpeed>5__2;

			private float <fallDelayElapsed>5__3;

			private float <targetT>5__4;

			private bool <wasAboveTarget>5__5;

			private bool <wasNeedleMoving>5__6;

			private bool <flag1>5__7;

			private bool <flag2>5__8;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.SetNeedlePosition(0f);
					<>4__this.needleJitter.StopJitter();
					<needleT>5__1 = 0f;
					<needleSpeed>5__2 = 0f;
					<fallDelayElapsed>5__3 = 0f;
					<targetT>5__4 = ((MinMaxFloat)(ref <>4__this.needleRange)).GetTBetween(<>4__this.needleTarget);
					<wasAboveTarget>5__5 = false;
					<wasNeedleMoving>5__6 = false;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this.wasMoving && !<>4__this.forceNeedleDrop)
				{
					<needleSpeed>5__2 = Mathf.Lerp(<needleSpeed>5__2, <>4__this.needleRiseSpeed * <>4__this.multiplier, Time.deltaTime * <>4__this.needleRiseLerpSpeed);
					<fallDelayElapsed>5__3 = 0f;
				}
				else if ((double)<needleT>5__1 <= 0.0)
				{
					<needleSpeed>5__2 = 0f;
				}
				else if ((double)<fallDelayElapsed>5__3 >= (double)<>4__this.needleFallDelay || <>4__this.forceNeedleDrop)
				{
					<needleSpeed>5__2 = Mathf.Lerp(<needleSpeed>5__2, 0f - <>4__this.needleFallSpeed, Time.deltaTime * <>4__this.needleFallLerpSpeed);
				}
				else
				{
					<needleSpeed>5__2 = Mathf.Lerp(<needleSpeed>5__2, 0f, Time.deltaTime * <>4__this.needleRiseLerpSpeed);
					<fallDelayElapsed>5__3 += Time.deltaTime;
				}
				<flag1>5__7 = (double)Math.Abs(<needleSpeed>5__2) > 0.009999999776482582;
				if (<flag1>5__7)
				{
					if (!<wasNeedleMoving>5__6)
					{
						<>4__this.needleJitter.StartJitter();
						<>4__this.needleRiseLoop.Play();
					}
				}
				else if (<wasNeedleMoving>5__6)
				{
					<>4__this.needleJitter.StopJitter();
					<>4__this.needleRiseLoop.Stop();
				}
				<needleT>5__1 = Mathf.Clamp01(<needleT>5__1 + <needleSpeed>5__2 * Time.deltaTime);
				if ((double)<>4__this.needleFpsLimit > 0.0)
				{
					if (Time.timeAsDouble > <>4__this.needleUpdateTime)
					{
						<>4__this.needleUpdateTime = Time.timeAsDouble + 1.0 / (double)<>4__this.needleFpsLimit;
						<>4__this.SetNeedlePosition(<needleT>5__1);
					}
				}
				else
				{
					<>4__this.SetNeedlePosition(<needleT>5__1);
				}
				if ((double)<needleT>5__1 <= 0.009999999776482582)
				{
					<>4__this.forceNeedleDrop = false;
				}
				<flag2>5__8 = (double)<needleT>5__1 >= (double)<targetT>5__4;
				if (<flag2>5__8)
				{
					if (!<wasAboveTarget>5__5)
					{
						<>4__this.needleFsm.SendEvent("NEEDLE ABOVE");
					}
				}
				else if (<wasAboveTarget>5__5)
				{
					<>4__this.needleFsm.SendEvent("NEEDLE BELOW");
				}
				<wasAboveTarget>5__5 = <flag2>5__8;
				<wasNeedleMoving>5__6 = <flag1>5__7;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

		[Header("Treadmill")]
		[SerializeField]
		private ConveyorBelt conveyorBelt;

		[SerializeField]
		private Animator speedControlAnimator;

		[SerializeField]
		private CogRotationController cogRotationController;

		[SerializeField]
		private Transform vectorCurveAnimatorParent;

		[SerializeField]
		private ParticleSystemPool moveParticles;

		[SerializeField]
		private AudioSource runSource;

		[SerializeField]
		private AudioEvent startRunSound;

		[SerializeField]
		private AudioSource sprintSource;

		[SerializeField]
		private AudioEvent startSprintSound;

		[SerializeField]
		private AudioEvent endRunSound;

		[Space]
		[SerializeField]
		private MinMaxFloat speedRange;

		[SerializeField]
		private MinMaxFloat speedXRange;

		[SerializeField]
		private float speedLerpMultiplier;

		[Space]
		[SerializeField]
		private float heroReferenceSpeed;

		[Header("Gauge")]
		[SerializeField]
		private Transform needlePivot;

		[SerializeField]
		private PlayMakerFSM needleFsm;

		[SerializeField]
		private AudioSource needleRiseLoop;

		[Space]
		[SerializeField]
		private MinMaxFloat needleRange;

		[SerializeField]
		private float needleTarget;

		[SerializeField]
		private float needleRiseSpeed;

		[SerializeField]
		private float needleRiseLerpSpeed;

		[SerializeField]
		private float needleFallDelay;

		[SerializeField]
		private float needleFallSpeed;

		[SerializeField]
		private float needleFallLerpSpeed;

		[SerializeField]
		private JitterSelf needleJitter;

		[SerializeField]
		private float needleFpsLimit;

		private float oldSpeedMult = -1f;

		private HeroController capturedHero;

		private HeroController lastCapturedHero;

		private float targetSpeed;

		private float multiplier;

		private float currentSpeed;

		private bool wasMoving;

		private bool forceNeedleDrop;

		private double needleUpdateTime;

		private VectorCurveAnimator[] curveAnimators;

		private static readonly int _speedAnimatorParam = Animator.StringToHash("Speed");

		private void OnDrawGizmosSelected()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			Gizmos.matrix = ((Component)this).transform.localToWorldMatrix;
			Gizmos.DrawLine(new Vector3(speedXRange.Start, 2f, 0f), new Vector3(speedXRange.Start, 4f, 0f));
			Gizmos.DrawLine(new Vector3(speedXRange.End, 2f, 0f), new Vector3(speedXRange.End, 4f, 0f));
		}

		private void OnValidate()
		{
			if (!((double)needleFpsLimit >= 0.0))
			{
				needleFpsLimit = 0f;
			}
		}

		private void Awake()
		{
			curveAnimators = (VectorCurveAnimator[])(Object.op_Implicit((Object)(object)vectorCurveAnimatorParent) ? ((Array)((Component)vectorCurveAnimatorParent).GetComponentsInChildren<VectorCurveAnimator>()) : ((Array)new VectorCurveAnimator[0]));
			conveyorBelt.CapturedHero += delegate(HeroController hero)
			{
				if (Object.op_Implicit((Object)(object)capturedHero))
				{
					capturedHero.BeforeApplyConveyorSpeed -= OnBeforeHeroConveyor;
				}
				if (Object.op_Implicit((Object)(object)hero))
				{
					hero.BeforeApplyConveyorSpeed += OnBeforeHeroConveyor;
					lastCapturedHero = hero;
				}
				else
				{
					targetSpeed = 0f;
				}
				capturedHero = hero;
			};
		}

		private void Start()
		{
			SetSpeedMultiplier(0f);
			((MonoBehaviour)this).StartCoroutine(NeedleControlRoutine());
		}

		public void OnDisable()
		{
			if (Object.op_Implicit((Object)(object)capturedHero))
			{
				capturedHero.BeforeApplyConveyorSpeed -= OnBeforeHeroConveyor;
			}
		}

		private void Update()
		{
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if ((double)Math.Abs(currentSpeed - targetSpeed) < 0.10000000149011612)
			{
				currentSpeed = targetSpeed;
			}
			currentSpeed = Mathf.Lerp(currentSpeed, targetSpeed, Time.deltaTime * speedLerpMultiplier);
			SetSpeedMultiplier(currentSpeed * multiplier);
			bool flag = (double)currentSpeed > 0.5;
			if (flag)
			{
				if (!wasMoving)
				{
					cogRotationController.ResetNextUpdateTime();
					moveParticles.PlayParticles();
					if (lastCapturedHero.cState.isSprinting)
					{
						((AudioEvent)(ref startSprintSound)).SpawnAndPlayOneShot(((Component)sprintSource).transform.position, (Action)null);
					}
					else
					{
						((AudioEvent)(ref startRunSound)).SpawnAndPlayOneShot(((Component)runSource).transform.position, (Action)null);
					}
				}
				if (lastCapturedHero.cState.isSprinting)
				{
					if (!sprintSource.isPlaying)
					{
						sprintSource.Play();
					}
					if (runSource.isPlaying)
					{
						runSource.Stop();
					}
				}
				else
				{
					if (sprintSource.isPlaying)
					{
						sprintSource.Stop();
					}
					if (!runSource.isPlaying)
					{
						runSource.Play();
					}
				}
			}
			else if (wasMoving)
			{
				moveParticles.StopParticles();
				((AudioEvent)(ref endRunSound)).SpawnAndPlayOneShot(((Component)runSource).transform.position, (Action)null);
				runSource.Stop();
				sprintSource.Stop();
			}
			wasMoving = flag;
		}

		private void OnBeforeHeroConveyor(Vector2 heroVelocity)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)this))
			{
				if ((double)heroVelocity.x < 0.0)
				{
					float tBetween = ((MinMaxFloat)(ref speedXRange)).GetTBetween(((Component)this).transform.InverseTransformPoint(capturedHero.transform.position).x);
					targetSpeed = (((double)tBetween > 0.0) ? ((MinMaxFloat)(ref speedRange)).GetLerpUnclampedValue(tBetween) : speedRange.Start);
					multiplier = heroVelocity.x / heroReferenceSpeed;
				}
				else
				{
					targetSpeed = 0f;
				}
			}
		}

		private void SetSpeedMultiplier(float value)
		{
			if (!((double)Math.Abs(value - oldSpeedMult) < 0.001))
			{
				oldSpeedMult = value;
				conveyorBelt.SpeedMultiplier = value;
				speedControlAnimator.SetFloat(HeroTreadmill._speedAnimatorParam, 0f - value);
				cogRotationController.RotationMultiplier = 0f - value;
				VectorCurveAnimator[] array = curveAnimators;
				foreach (VectorCurveAnimator val in array)
				{
					val.SpeedMultiplier = value;
				}
			}
		}

		[IteratorStateMachine(typeof(<NeedleControlRoutine>d__45))]
		private IEnumerator NeedleControlRoutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <NeedleControlRoutine>d__45(0)
			{
				<>4__this = this
			};
		}

		private void SetNeedlePosition(float value)
		{
			Extensions.SetLocalRotation2D(((Component)needlePivot).transform, ((MinMaxFloat)(ref needleRange)).GetLerpedValue(value));
		}

		public void DropNeedle()
		{
			forceNeedleDrop = true;
		}
	}
	public class iTween2d : MonoBehaviour
	{
		private delegate float EasingFunction(float start, float end, float Value);

		private delegate void ApplyTween();

		public enum EaseType
		{
			easeInQuad,
			easeOutQuad,
			easeInOutQuad,
			easeInCubic,
			easeOutCubic,
			easeInOutCubic,
			easeInQuart,
			easeOutQuart,
			easeInOutQuart,
			easeInQuint,
			easeOutQuint,
			easeInOutQuint,
			easeInSine,
			easeOutSine,
			easeInOutSine,
			easeInExpo,
			easeOutExpo,
			easeInOutExpo,
			easeInCirc,
			easeOutCirc,
			easeInOutCirc,
			linear,
			spring,
			easeInBounce,
			easeOutBounce,
			easeInOutBounce,
			easeInBack,
			easeOutBack,
			easeInOutBack,
			easeInElastic,
			easeOutElastic,
			easeInOutElastic,
			punch
		}

		public enum LoopType
		{
			none,
			loop,
			pingPong
		}

		public enum NamedValueColor
		{
			_Color,
			_SpecColor,
			_Emission,
			_ReflectColor
		}

		public static class Defaults
		{
			public static float time = 1f;

			public static float delay = 0f;

			public static NamedValueColor namedColorValue = NamedValueColor._Color;

			public static LoopType loopType = LoopType.none;

			public static EaseType easeType = EaseType.easeOutExpo;

			public static float lookSpeed = 3f;

			public static bool isLocal = false;

			public static Space space = (Space)1;

			public static bool orientToPath = false;

			public static Color color = Color.white;

			public static float updateTimePercentage = 0.05f;

			public static float updateTime = 1f * updateTimePercentage;

			public static float lookAhead = 0.05f;

			public static bool useRealTime = false;

			public static Vector3 up = Vector3.up;
		}

		private class CRSpline
		{
			public Vector3[] pts;

			public CRSpline(params Vector3[] pts)
			{
				this.pts = (Vector3[])(object)new Vector3[pts.Length];
				Array.Copy(pts, this.pts, pts.Length);
			}

			public Vector3 Interp(float t)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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_0073: 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_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: 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)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				int num = pts.Length - 3;
				int num2 = Mathf.Min(Mathf.FloorToInt(t * (float)num), num - 1);
				float num3 = t * (float)num - (float)num2;
				Vector3 val = pts[num2];
				Vector3 val2 = pts[num2 + 1];
				Vector3 val3 = pts[num2 + 2];
				Vector3 val4 = pts[num2 + 3];
				return 0.5f * ((-val + 3f * val2 - 3f * val3 + val4) * (num3 * num3 * num3) + (2f * val - 5f * val2 + 4f * val3 - val4) * (num3 * num3) + (-val + val3) * num3 + 2f * val2);
			}
		}

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

			private object <>2__current;

			public iTween2d <>4__this;

			private iTween2d <iTween2d>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<iTween2d>5__1 = <>4__this;
					if ((double)<iTween2d>5__1.delay > 0.0)
					{
						<>2__current = ((MonoBehaviour)<iTween2d>5__1).StartCoroutine("TweenDelay");
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<iTween2d>5__1.TweenStart();
				return false;
			}

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

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

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

			private object <>2__current;

			public iTween2d <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.delayStarted = Time.timeAsDouble;
					<>2__current = (object)new WaitForSeconds(<>4__this.delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (<>4__this.wasPaused)
					{
						<>4__this.wasPaused = false;
						<>4__this.TweenStart();
					}
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public iTween2d <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((double)<>4__this.delay > 0.0)
					{
						<>4__this.delayStarted = Time.timeAsDouble;
						<>2__current = (object)new WaitForSeconds(<>4__this.delay);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<>4__this.loop = true;
				<>4__this.TweenStart();
				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 static List<Hashtable> tweens = new List<Hashtable>();

		public string id;

		public string type;

		public string method;

		public EaseType easeType;

		public float time;

		public float delay;

		public LoopType loopType;

		public bool isRunning;

		public bool isPaused;

		public string _name;

		private float runningTime;

		private float percentage;

		private double delayStarted;

		private bool isLocal;

		private bool loop;

		private bool reverse;

		private bool wasPaused;

		private bool physics;

		private Hashtable tweenArguments;

		private Space space;

		private EasingFunction ease;

		private ApplyTween apply;

		private AudioSource audioSource;

		private Vector3[] vector3s;

		private Vector2[] vector2s;

		private Color[,] colors;

		private float[] floats;

		private Rect[] rects;

		private CRSpline path;

		private Vector3 preUpdate;

		private Vector3 postUpdate;

		private NamedValueColor namedcolorvalue;

		private double lastRealTime;

		private bool useRealTime;

		private Transform thisTransform;

		public bool IsValid { get; private set; }

		public static void Init(GameObject target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			MoveBy(target, Vector3.zero, 0f);
		}

		public static void ValueTo(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			if (!args.Contains("onupdate") || !args.Contains("from") || !args.Contains("to"))
			{
				Debug.LogError((object)"iTween2d Error: ValueTo() requires an 'onupdate' callback function and a 'from' and 'to' property.  The supplied 'onupdate' callback must accept a single argument that is the same type as the supplied 'from' and 'to' properties!");
				return;
			}
			args["type"] = "value";
			if (args["from"].GetType() == typeof(Vector2))
			{
				args["method"] = "vector2";
			}
			else if (args["from"].GetType() == typeof(Vector3))
			{
				args["method"] = "vector3";
			}
			else if (args["from"].GetType() == typeof(Rect))
			{
				args["method"] = "rect";
			}
			else if (args["from"].GetType() == typeof(float))
			{
				args["method"] = "float";
			}
			else
			{
				if (!(args["from"].GetType() == typeof(Color)))
				{
					Debug.LogError((object)"iTween2d Error: ValueTo() only works with interpolating Vector3s, Vector2s, floats, ints, Rects and Colors!");
					return;
				}
				args["method"] = "color";
			}
			if (!args.Contains("easetype"))
			{
				args.Add("easetype", EaseType.linear);
			}
			Launch(target, args);
		}

		public static void FadeFrom(GameObject target, float alpha, float time)
		{
			FadeFrom(target, Hash("alpha", alpha, "time", time));
		}

		public static void FadeFrom(GameObject target, Hashtable args)
		{
			ColorFrom(target, args);
		}

		public static void FadeTo(GameObject target, float alpha, float time)
		{
			FadeTo(target, Hash("alpha", alpha, "time", time));
		}

		public static void FadeTo(GameObject target, Hashtable args)
		{
			ColorTo(target, args);
		}

		public static void ColorFrom(GameObject target, Color color, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ColorFrom(target, Hash("color", color, "time", time));
		}

		public static void ColorFrom(GameObject target, Hashtable args)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			Color color = default(Color);
			Color val = default(Color);
			args = CleanArgs(args);
			if (!args.Contains("includechildren") || (bool)args["includechildren"])
			{
				foreach (Transform item in target.transform)
				{
					Transform val2 = item;
					Hashtable hashtable = (Hashtable)args.Clone();
					hashtable["ischild"] = true;
					ColorFrom(((Component)val2).gameObject, hashtable);
				}
			}
			if (!args.Contains("easetype"))
			{
				args.Add("easetype", EaseType.linear);
			}
			if (Object.op_Implicit((Object)(object)target.GetComponent<Renderer>()))
			{
				val = (color = target.GetComponent<Renderer>().material.color);
			}
			else if (Object.op_Implicit((Object)(object)target.GetComponent<Light>()))
			{
				val = (color = target.GetComponent<Light>().color);
			}
			if (args.Contains("color"))
			{
				color = (Color)args["color"];
			}
			else
			{
				if (args.Contains("r"))
				{
					color.r = (float)args["r"];
				}
				if (args.Contains("g"))
				{
					color.g = (float)args["g"];
				}
				if (args.Contains("b"))
				{
					color.b = (float)args["b"];
				}
				if (args.Contains("a"))
				{
					color.a = (float)args["a"];
				}
			}
			if (args.Contains("amount"))
			{
				color.a = (float)args["amount"];
				args.Remove("amount");
			}
			else if (args.Contains("alpha"))
			{
				color.a = (float)args["alpha"];
				args.Remove("alpha");
			}
			if (Object.op_Implicit((Object)(object)target.GetComponent<Renderer>()))
			{
				target.GetComponent<Renderer>().material.color = color;
			}
			else if (Object.op_Implicit((Object)(object)target.GetComponent<Light>()))
			{
				target.GetComponent<Light>().color = color;
			}
			args["color"] = val;
			args["type"] = "color";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void ColorTo(GameObject target, Color color, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ColorTo(target, Hash("color", color, "time", time));
		}

		public static void ColorTo(GameObject target, Hashtable args)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			args = CleanArgs(args);
			if (!args.Contains("includechildren") || (bool)args["includechildren"])
			{
				foreach (Transform item in target.transform)
				{
					Transform val = item;
					Hashtable hashtable = (Hashtable)args.Clone();
					hashtable["ischild"] = true;
					ColorTo(((Component)val).gameObject, hashtable);
				}
			}
			if (!args.Contains("easetype"))
			{
				args.Add("easetype", EaseType.linear);
			}
			args["type"] = "color";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void AudioFrom(GameObject target, float volume, float pitch, float time)
		{
			AudioFrom(target, Hash("volume", volume, "pitch", pitch, "time", time));
		}

		public static void AudioFrom(GameObject target, Hashtable args)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_00db: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			AudioSource val;
			if (args.Contains("audiosource"))
			{
				val = (AudioSource)args["audiosource"];
			}
			else
			{
				if (!Object.op_Implicit((Object)(object)target.GetComponent<AudioSource>()))
				{
					Debug.LogError((object)"iTween2d Error: AudioFrom requires an AudioSource.");
					return;
				}
				val = target.GetComponent<AudioSource>();
			}
			Vector2 val2 = default(Vector2);
			Vector2 val3 = default(Vector2);
			val2.x = (val3.x = val.volume);
			val2.y = (val3.y = val.pitch);
			if (args.Contains("volume"))
			{
				val3.x = (float)args["volume"];
			}
			if (args.Contains("pitch"))
			{
				val3.y = (float)args["pitch"];
			}
			val.volume = val3.x;
			val.pitch = val3.y;
			args["volume"] = val2.x;
			args["pitch"] = val2.y;
			if (!args.Contains("easetype"))
			{
				args.Add("easetype", EaseType.linear);
			}
			args["type"] = "audio";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void AudioTo(GameObject target, float volume, float pitch, float time)
		{
			AudioTo(target, Hash("volume", volume, "pitch", pitch, "time", time));
		}

		public static void AudioTo(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			if (!args.Contains("easetype"))
			{
				args.Add("easetype", EaseType.linear);
			}
			args["type"] = "audio";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void Stab(GameObject target, AudioClip audioclip, float delay)
		{
			Stab(target, Hash("audioclip", audioclip, "delay", delay));
		}

		public static void Stab(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "stab";
			Launch(target, args);
		}

		public static void LookFrom(GameObject target, Vector3 looktarget, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			LookFrom(target, Hash("looktarget", looktarget, "time", time));
		}

		public static void LookFrom(GameObject target, Hashtable args)
		{
			//IL_000f: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			Vector3 eulerAngles = target.transform.eulerAngles;
			if (args["looktarget"].GetType() == typeof(Transform))
			{
				target.transform.LookAt((Transform)args["looktarget"], (Vector3)(((??)(Vector3?)args["up"]) ?? Defaults.up));
			}
			else if (args["looktarget"].GetType() == typeof(Vector3))
			{
				target.transform.LookAt((Vector3)args["looktarget"], (Vector3)(((??)(Vector3?)args["up"]) ?? Defaults.up));
			}
			if (args.Contains("axis"))
			{
				Vector3 eulerAngles2 = target.transform.eulerAngles;
				switch ((string)args["axis"])
				{
				case "x":
					eulerAngles2.y = eulerAngles.y;
					eulerAngles2.z = eulerAngles.z;
					break;
				case "y":
					eulerAngles2.x = eulerAngles.x;
					eulerAngles2.z = eulerAngles.z;
					break;
				case "z":
					eulerAngles2.x = eulerAngles.x;
					eulerAngles2.y = eulerAngles.y;
					break;
				}
				target.transform.eulerAngles = eulerAngles2;
			}
			args["rotation"] = eulerAngles;
			args["type"] = "rotate";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void LookTo(GameObject target, Vector3 looktarget, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			LookTo(target, Hash("looktarget", looktarget, "time", time));
		}

		public static void LookTo(GameObject target, Hashtable args)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0058: 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_006e: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			if (args.Contains("looktarget") && args["looktarget"].GetType() == typeof(Transform))
			{
				Transform val = (Transform)args["looktarget"];
				args["position"] = (object)new Vector3(val.position.x, val.position.y, val.position.z);
				args["rotation"] = (object)new Vector3(val.eulerAngles.x, val.eulerAngles.y, val.eulerAngles.z);
			}
			args["type"] = "look";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void MoveTo(GameObject target, Vector3 position, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			MoveTo(target, Hash("position", position, "time", time));
		}

		public static void MoveTo(GameObject target, Hashtable args)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0058: 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_006e: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			if (args.Contains("position") && args["position"].GetType() == typeof(Transform))
			{
				Transform val = (Transform)args["position"];
				args["position"] = (object)new Vector3(val.position.x, val.position.y, val.position.z);
				args["rotation"] = (object)new Vector3(val.eulerAngles.x, val.eulerAngles.y, val.eulerAngles.z);
				args["scale"] = (object)new Vector3(val.localScale.x, val.localScale.y, val.localScale.z);
			}
			args["type"] = "move";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void MoveFrom(GameObject target, Vector3 position, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			MoveFrom(target, Hash("position", position, "time", time));
		}

		public static void MoveFrom(GameObject target, Hashtable args)
		{
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: 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_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			bool flag = ((!args.Contains("islocal")) ? Defaults.isLocal : ((bool)args["islocal"]));
			if (args.Contains("path"))
			{
				Vector3[] array2;
				if (args["path"].GetType() == typeof(Vector3[]))
				{
					Vector3[] array = (Vector3[])args["path"];
					array2 = (Vector3[])(object)new Vector3[array.Length];
					Array.Copy(array, array2, array.Length);
				}
				else
				{
					Transform[] array3 = (Transform[])args["path"];
					array2 = (Vector3[])(object)new Vector3[array3.Length];
					for (int i = 0; i < array3.Length; i++)
					{
						array2[i] = array3[i].position;
					}
				}
				if (array2[^1] != target.transform.position)
				{
					Vector3[] array4 = (Vector3[])(object)new Vector3[array2.Length + 1];
					Array.Copy(array2, array4, array2.Length);
					if (flag)
					{
						array4[^1] = target.transform.localPosition;
						target.transform.localPosition = array4[0];
					}
					else
					{
						array4[^1] = target.transform.position;
						target.transform.position = array4[0];
					}
					args["path"] = array4;
				}
				else
				{
					if (flag)
					{
						target.transform.localPosition = array2[0];
					}
					else
					{
						target.transform.position = array2[0];
					}
					args["path"] = array2;
				}
			}
			else
			{
				Vector3 val;
				Vector3 val2 = (flag ? (val = target.transform.localPosition) : (val = target.transform.position));
				if (args.Contains("position"))
				{
					if (args["position"].GetType() == typeof(Transform))
					{
						val = ((Transform)args["position"]).position;
					}
					else if (args["position"].GetType() == typeof(Vector3))
					{
						val = (Vector3)args["position"];
					}
				}
				else
				{
					if (args.Contains("x"))
					{
						val.x = (float)args["x"];
					}
					if (args.Contains("y"))
					{
						val.y = (float)args["y"];
					}
					if (args.Contains("z"))
					{
						val.z = (float)args["z"];
					}
				}
				if (flag)
				{
					target.transform.localPosition = val;
				}
				else
				{
					target.transform.position = val;
				}
				args["position"] = val2;
			}
			args["type"] = "move";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void MoveAdd(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			MoveAdd(target, Hash("amount", amount, "time", time));
		}

		public static void MoveAdd(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "move";
			args["method"] = "add";
			Launch(target, args);
		}

		public static void MoveBy(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			MoveBy(target, Hash("amount", amount, "time", time));
		}

		public static void MoveBy(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "move";
			args["method"] = "by";
			Launch(target, args);
		}

		public static void ScaleTo(GameObject target, Vector3 scale, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ScaleTo(target, Hash("scale", scale, "time", time));
		}

		public static void ScaleTo(GameObject target, Hashtable args)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0058: 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_006e: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			if (args.Contains("scale") && args["scale"].GetType() == typeof(Transform))
			{
				Transform val = (Transform)args["scale"];
				args["position"] = (object)new Vector3(val.position.x, val.position.y, val.position.z);
				args["rotation"] = (object)new Vector3(val.eulerAngles.x, val.eulerAngles.y, val.eulerAngles.z);
				args["scale"] = (object)new Vector3(val.localScale.x, val.localScale.y, val.localScale.z);
			}
			args["type"] = "scale";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void ScaleFrom(GameObject target, Vector3 scale, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ScaleFrom(target, Hash("scale", scale, "time", time));
		}

		public static void ScaleFrom(GameObject target, Hashtable args)
		{
			//IL_000f: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			Vector3 localScale;
			Vector3 val = (localScale = target.transform.localScale);
			if (args.Contains("scale"))
			{
				if (args["scale"].GetType() == typeof(Transform))
				{
					localScale = ((Transform)args["scale"]).localScale;
				}
				else if (args["scale"].GetType() == typeof(Vector3))
				{
					localScale = (Vector3)args["scale"];
				}
			}
			else
			{
				if (args.Contains("x"))
				{
					localScale.x = (float)args["x"];
				}
				if (args.Contains("y"))
				{
					localScale.y = (float)args["y"];
				}
				if (args.Contains("z"))
				{
					localScale.z = (float)args["z"];
				}
			}
			target.transform.localScale = localScale;
			args["scale"] = val;
			args["type"] = "scale";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void ScaleAdd(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ScaleAdd(target, Hash("amount", amount, "time", time));
		}

		public static void ScaleAdd(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "scale";
			args["method"] = "add";
			Launch(target, args);
		}

		public static void ScaleBy(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ScaleBy(target, Hash("amount", amount, "time", time));
		}

		public static void ScaleBy(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "scale";
			args["method"] = "by";
			Launch(target, args);
		}

		public static void RotateTo(GameObject target, Vector3 rotation, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			RotateTo(target, Hash("rotation", rotation, "time", time));
		}

		public static void RotateTo(GameObject target, Hashtable args)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0058: 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_006e: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			if (args.Contains("rotation") && args["rotation"].GetType() == typeof(Transform))
			{
				Transform val = (Transform)args["rotation"];
				args["position"] = (object)new Vector3(val.position.x, val.position.y, val.position.z);
				args["rotation"] = (object)new Vector3(val.eulerAngles.x, val.eulerAngles.y, val.eulerAngles.z);
				args["scale"] = (object)new Vector3(val.localScale.x, val.localScale.y, val.localScale.z);
			}
			args["type"] = "rotate";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void RotateFrom(GameObject target, Vector3 rotation, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			RotateFrom(target, Hash("rotation", rotation, "time", time));
		}

		public static void RotateFrom(GameObject target, Hashtable args)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			args = CleanArgs(args);
			bool flag = ((!args.Contains("islocal")) ? Defaults.isLocal : ((bool)args["islocal"]));
			Vector3 val;
			Vector3 val2 = (flag ? (val = target.transform.localEulerAngles) : (val = target.transform.eulerAngles));
			if (args.Contains("rotation"))
			{
				if (args["rotation"].GetType() == typeof(Transform))
				{
					val = ((Transform)args["rotation"]).eulerAngles;
				}
				else if (args["rotation"].GetType() == typeof(Vector3))
				{
					val = (Vector3)args["rotation"];
				}
			}
			else
			{
				if (args.Contains("x"))
				{
					val.x = (float)args["x"];
				}
				if (args.Contains("y"))
				{
					val.y = (float)args["y"];
				}
				if (args.Contains("z"))
				{
					val.z = (float)args["z"];
				}
			}
			if (flag)
			{
				target.transform.localEulerAngles = val;
			}
			else
			{
				target.transform.eulerAngles = val;
			}
			args["rotation"] = val2;
			args["type"] = "rotate";
			args["method"] = "to";
			Launch(target, args);
		}

		public static void RotateAdd(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			RotateAdd(target, Hash("amount", amount, "time", time));
		}

		public static void RotateAdd(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "rotate";
			args["method"] = "add";
			Launch(target, args);
		}

		public static void RotateBy(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			RotateBy(target, Hash("amount", amount, "time", time));
		}

		public static void RotateBy(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "rotate";
			args["method"] = "by";
			Launch(target, args);
		}

		public static void ShakePosition(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ShakePosition(target, Hash("amount", amount, "time", time));
		}

		public static void ShakePosition(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "shake";
			args["method"] = "position";
			Launch(target, args);
		}

		public static void ShakeScale(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ShakeScale(target, Hash("amount", amount, "time", time));
		}

		public static void ShakeScale(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "shake";
			args["method"] = "scale";
			Launch(target, args);
		}

		public static void ShakeRotation(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ShakeRotation(target, Hash("amount", amount, "time", time));
		}

		public static void ShakeRotation(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "shake";
			args["method"] = "rotation";
			Launch(target, args);
		}

		public static void PunchPosition(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			PunchPosition(target, Hash("amount", amount, "time", time));
		}

		public static void PunchPosition(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "punch";
			args["method"] = "position";
			args["easetype"] = EaseType.punch;
			Launch(target, args);
		}

		public static void PunchRotation(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			PunchRotation(target, Hash("amount", amount, "time", time));
		}

		public static void PunchRotation(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "punch";
			args["method"] = "rotation";
			args["easetype"] = EaseType.punch;
			Launch(target, args);
		}

		public static void PunchScale(GameObject target, Vector3 amount, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			PunchScale(target, Hash("amount", amount, "time", time));
		}

		public static void PunchScale(GameObject target, Hashtable args)
		{
			args = CleanArgs(args);
			args["type"] = "punch";
			args["method"] = "scale";
			args["easetype"] = EaseType.punch;
			Launch(target, args);
		}

		private void GenerateRectTargets()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			rects = (Rect[])(object)new Rect[3];
			rects[0] = (Rect)tweenArguments["from"];
			rects[1] = (Rect)tweenArguments["to"];
		}

		private void GenerateColorTargets()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			colors = new Color[1, 3];
			colors[0, 0] = (Color)tweenArguments["from"];
			colors[0, 1] = (Color)tweenArguments["to"];
		}

		private void GenerateVector3Targets()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = (Vector3)tweenArguments["from"];
			vector3s[1] = (Vector3)tweenArguments["to"];
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateVector2Targets()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			vector2s = (Vector2[])(object)new Vector2[3];
			vector2s[0] = (Vector2)tweenArguments["from"];
			vector2s[1] = (Vector2)tweenArguments["to"];
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(new Vector3(vector2s[0].x, vector2s[0].y, 0f), new Vector3(vector2s[1].x, vector2s[1].y, 0f))) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateFloatTargets()
		{
			floats = new float[3];
			floats[0] = (float)tweenArguments["from"];
			floats[1] = (float)tweenArguments["to"];
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(floats[0] - floats[1]) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateColorToTargets()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<Renderer>()))
			{
				colors = new Color[((Component)this).GetComponent<Renderer>().materials.Length, 3];
				for (int i = 0; i < ((Component)this).GetComponent<Renderer>().materials.Length; i++)
				{
					colors[i, 0] = ((Component)this).GetComponent<Renderer>().materials[i].GetColor(namedcolorvalue.ToString());
					colors[i, 1] = ((Component)this).GetComponent<Renderer>().materials[i].GetColor(namedcolorvalue.ToString());
				}
			}
			else if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<Light>()))
			{
				colors = new Color[1, 3];
				colors[0, 0] = (colors[0, 1] = ((Component)this).GetComponent<Light>().color);
			}
			else
			{
				colors = new Color[1, 3];
			}
			if (tweenArguments.Contains("color"))
			{
				for (int j = 0; j < colors.GetLength(0); j++)
				{
					colors[j, 1] = (Color)tweenArguments["color"];
				}
			}
			else
			{
				if (tweenArguments.Contains("r"))
				{
					for (int k = 0; k < colors.GetLength(0); k++)
					{
						colors[k, 1].r = (float)tweenArguments["r"];
					}
				}
				if (tweenArguments.Contains("g"))
				{
					for (int l = 0; l < colors.GetLength(0); l++)
					{
						colors[l, 1].g = (float)tweenArguments["g"];
					}
				}
				if (tweenArguments.Contains("b"))
				{
					for (int m = 0; m < colors.GetLength(0); m++)
					{
						colors[m, 1].b = (float)tweenArguments["b"];
					}
				}
				if (tweenArguments.Contains("a"))
				{
					for (int n = 0; n < colors.GetLength(0); n++)
					{
						colors[n, 1].a = (float)tweenArguments["a"];
					}
				}
			}
			if (tweenArguments.Contains("amount"))
			{
				for (int num = 0; num < colors.GetLength(0); num++)
				{
					colors[num, 1].a = (float)tweenArguments["amount"];
				}
			}
			else if (tweenArguments.Contains("alpha"))
			{
				for (int num2 = 0; num2 < colors.GetLength(0); num2++)
				{
					colors[num2, 1].a = (float)tweenArguments["alpha"];
				}
			}
		}

		private void GenerateAudioToTargets()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			vector2s = (Vector2[])(object)new Vector2[3];
			if (tweenArguments.Contains("audiosource"))
			{
				audioSource = (AudioSource)tweenArguments["audiosource"];
			}
			else if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<AudioSource>()))
			{
				audioSource = ((Component)this).GetComponent<AudioSource>();
			}
			else
			{
				Debug.LogError((object)"iTween2d Error: AudioTo requires an AudioSource.");
				Dispose();
			}
			vector2s[0] = (vector2s[1] = new Vector2(audioSource.volume, audioSource.pitch));
			if (tweenArguments.Contains("volume"))
			{
				vector2s[1].x = (float)tweenArguments["volume"];
			}
			if (tweenArguments.Contains("pitch"))
			{
				vector2s[1].y = (float)tweenArguments["pitch"];
			}
		}

		private void GenerateStabTargets()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			if (tweenArguments.Contains("audiosource"))
			{
				audioSource = (AudioSource)tweenArguments["audiosource"];
			}
			else if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<AudioSource>()))
			{
				audioSource = ((Component)this).GetComponent<AudioSource>();
			}
			else
			{
				((Component)this).gameObject.AddComponent<AudioSource>();
				audioSource = ((Component)this).GetComponent<AudioSource>();
				audioSource.playOnAwake = false;
			}
			audioSource.clip = (AudioClip)tweenArguments["audioclip"];
			if (tweenArguments.Contains("pitch"))
			{
				audioSource.pitch = (float)tweenArguments["pitch"];
			}
			if (tweenArguments.Contains("volume"))
			{
				audioSource.volume = (float)tweenArguments["volume"];
			}
			time = audioSource.clip.length / audioSource.pitch;
		}

		private void GenerateLookToTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = thisTransform.eulerAngles;
			if (tweenArguments.Contains("looktarget"))
			{
				if (tweenArguments["looktarget"].GetType() == typeof(Transform))
				{
					thisTransform.LookAt((Transform)tweenArguments["looktarget"], (Vector3)(((??)(Vector3?)tweenArguments["up"]) ?? Defaults.up));
				}
				else if (tweenArguments["looktarget"].GetType() == typeof(Vector3))
				{
					thisTransform.LookAt((Vector3)tweenArguments["looktarget"], (Vector3)(((??)(Vector3?)tweenArguments["up"]) ?? Defaults.up));
				}
			}
			else
			{
				Debug.LogError((object)"iTween2d Error: LookTo needs a 'looktarget' property!");
				Dispose();
			}
			vector3s[1] = thisTransform.eulerAngles;
			thisTransform.eulerAngles = vector3s[0];
			if (tweenArguments.Contains("axis"))
			{
				switch ((string)tweenArguments["axis"])
				{
				case "x":
					vector3s[1].y = vector3s[0].y;
					vector3s[1].z = vector3s[0].z;
					break;
				case "y":
					vector3s[1].x = vector3s[0].x;
					vector3s[1].z = vector3s[0].z;
					break;
				case "z":
					vector3s[1].x = vector3s[0].x;
					vector3s[1].y = vector3s[0].y;
					break;
				}
			}
			vector3s[1] = new Vector3(clerp(vector3s[0].x, vector3s[1].x, 1f), clerp(vector3s[0].y, vector3s[1].y, 1f), clerp(vector3s[0].z, vector3s[1].z, 1f));
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateMoveToPathTargets()
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: 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_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array2;
			if (tweenArguments["path"].GetType() == typeof(Vector3[]))
			{
				Vector3[] array = (Vector3[])tweenArguments["path"];
				if (array.Length == 1)
				{
					Debug.LogError((object)"iTween2d Error: Attempting a path movement with MoveTo requires an array of more than 1 entry!");
					Dispose();
				}
				array2 = (Vector3[])(object)new Vector3[array.Length];
				Array.Copy(array, array2, array.Length);
			}
			else
			{
				Transform[] array3 = (Transform[])tweenArguments["path"];
				if (array3.Length == 1)
				{
					Debug.LogError((object)"iTween2d Error: Attempting a path movement with MoveTo requires an array of more than 1 entry!");
					Dispose();
				}
				array2 = (Vector3[])(object)new Vector3[array3.Length];
				for (int i = 0; i < array3.Length; i++)
				{
					array2[i] = array3[i].position;
				}
			}
			bool flag;
			int num;
			if (thisTransform.position != array2[0])
			{
				if (!tweenArguments.Contains("movetopath") || (bool)tweenArguments["movetopath"])
				{
					flag = true;
					num = 3;
				}
				else
				{
					flag = false;
					num = 2;
				}
			}
			else
			{
				flag = false;
				num = 2;
			}
			vector3s = (Vector3[])(object)new Vector3[array2.Length + num];
			int destinationIndex;
			if (flag)
			{
				vector3s[1] = thisTransform.position;
				destinationIndex = 2;
			}
			else
			{
				destinationIndex = 1;
			}
			Array.Copy(array2, 0, vector3s, destinationIndex, array2.Length);
			vector3s[0] = vector3s[1] + (vector3s[1] - vector3s[2]);
			vector3s[vector3s.Length - 1] = vector3s[vector3s.Length - 2] + (vector3s[vector3s.Length - 2] - vector3s[vector3s.Length - 3]);
			if (vector3s[1] == vector3s[vector3s.Length - 2])
			{
				Vector3[] array4 = (Vector3[])(object)new Vector3[vector3s.Length];
				Array.Copy(vector3s, array4, vector3s.Length);
				array4[0] = array4[^3];
				array4[^1] = array4[2];
				vector3s = (Vector3[])(object)new Vector3[array4.Length];
				Array.Copy(array4, vector3s, array4.Length);
			}
			path = new CRSpline(vector3s);
			if (tweenArguments.Contains("speed"))
			{
				time = PathLength(vector3s) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateMoveToTargets()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = ((!isLocal) ? (vector3s[1] = thisTransform.position) : (vector3s[1] = thisTransform.localPosition));
			if (tweenArguments.Contains("position"))
			{
				if (tweenArguments["position"].GetType() == typeof(Transform))
				{
					vector3s[1] = ((Transform)tweenArguments["position"]).position;
				}
				else if (tweenArguments["position"].GetType() == typeof(Vector3))
				{
					vector3s[1] = (Vector3)tweenArguments["position"];
				}
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x = (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y = (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z = (float)tweenArguments["z"];
				}
			}
			if (tweenArguments.Contains("orienttopath") && (bool)tweenArguments["orienttopath"])
			{
				tweenArguments["looktarget"] = vector3s[1];
			}
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateMoveByTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[6];
			vector3s[4] = thisTransform.eulerAngles;
			vector3s[0] = (vector3s[1] = (vector3s[3] = thisTransform.position));
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = vector3s[0] + (Vector3)tweenArguments["amount"];
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x = vector3s[0].x + (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y = vector3s[0].y + (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z = vector3s[0].z + (float)tweenArguments["z"];
				}
			}
			thisTransform.Translate(vector3s[1], space);
			vector3s[5] = thisTransform.position;
			thisTransform.position = vector3s[0];
			if (tweenArguments.Contains("orienttopath") && (bool)tweenArguments["orienttopath"])
			{
				tweenArguments["looktarget"] = vector3s[1];
			}
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateScaleToTargets()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002e: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = (vector3s[1] = thisTransform.localScale);
			if (tweenArguments.Contains("scale"))
			{
				if (tweenArguments["scale"].GetType() == typeof(Transform))
				{
					vector3s[1] = ((Transform)tweenArguments["scale"]).localScale;
				}
				else if (tweenArguments["scale"].GetType() == typeof(Vector3))
				{
					vector3s[1] = (Vector3)tweenArguments["scale"];
				}
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x = (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y = (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z = (float)tweenArguments["z"];
				}
			}
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateScaleByTargets()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = (vector3s[1] = thisTransform.localScale);
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = Vector3.Scale(vector3s[1], (Vector3)tweenArguments["amount"]);
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x *= (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y *= (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z *= (float)tweenArguments["z"];
				}
			}
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateScaleAddTargets()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = (vector3s[1] = thisTransform.localScale);
			if (tweenArguments.Contains("amount"))
			{
				ref Vector3 reference = ref vector3s[1];
				reference += (Vector3)tweenArguments["amount"];
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x += (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y += (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z += (float)tweenArguments["z"];
				}
			}
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateRotateToTargets()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = ((!isLocal) ? (vector3s[1] = thisTransform.eulerAngles) : (vector3s[1] = thisTransform.localEulerAngles));
			if (tweenArguments.Contains("rotation"))
			{
				if (tweenArguments["rotation"].GetType() == typeof(Transform))
				{
					vector3s[1] = ((Transform)tweenArguments["rotation"]).eulerAngles;
				}
				else if (tweenArguments["rotation"].GetType() == typeof(Vector3))
				{
					vector3s[1] = (Vector3)tweenArguments["rotation"];
				}
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x = (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y = (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z = (float)tweenArguments["z"];
				}
			}
			vector3s[1] = new Vector3(clerp(vector3s[0].x, vector3s[1].x, 1f), clerp(vector3s[0].y, vector3s[1].y, 1f), clerp(vector3s[0].z, vector3s[1].z, 1f));
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateRotateAddTargets()
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[5];
			vector3s[0] = (vector3s[1] = (vector3s[3] = thisTransform.eulerAngles));
			if (tweenArguments.Contains("amount"))
			{
				ref Vector3 reference = ref vector3s[1];
				reference += (Vector3)tweenArguments["amount"];
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x += (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y += (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z += (float)tweenArguments["z"];
				}
			}
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateRotateByTargets()
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[4];
			vector3s[0] = (vector3s[1] = (vector3s[3] = thisTransform.eulerAngles));
			if (tweenArguments.Contains("amount"))
			{
				ref Vector3 reference = ref vector3s[1];
				reference += Vector3.Scale((Vector3)tweenArguments["amount"], new Vector3(360f, 360f, 360f));
			}
			else
			{
				if (tweenArguments.Contains("x"))
				{
					vector3s[1].x += 360f * (float)tweenArguments["x"];
				}
				if (tweenArguments.Contains("y"))
				{
					vector3s[1].y += 360f * (float)tweenArguments["y"];
				}
				if (tweenArguments.Contains("z"))
				{
					vector3s[1].z += 360f * (float)tweenArguments["z"];
				}
			}
			if (tweenArguments.Contains("speed"))
			{
				time = Math.Abs(Vector3.Distance(vector3s[0], vector3s[1])) / (float)tweenArguments["speed"];
			}
		}

		private void GenerateShakePositionTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			vector3s = (Vector3[])(object)new Vector3[4];
			vector3s[3] = thisTransform.eulerAngles;
			vector3s[0] = thisTransform.position;
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = (Vector3)tweenArguments["amount"];
				return;
			}
			if (tweenArguments.Contains("x"))
			{
				vector3s[1].x = (float)tweenArguments["x"];
			}
			if (tweenArguments.Contains("y"))
			{
				vector3s[1].y = (float)tweenArguments["y"];
			}
			if (tweenArguments.Contains("z"))
			{
				vector3s[1].z = (float)tweenArguments["z"];
			}
		}

		private void GenerateShakeScaleTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = thisTransform.localScale;
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = (Vector3)tweenArguments["amount"];
				return;
			}
			if (tweenArguments.Contains("x"))
			{
				vector3s[1].x = (float)tweenArguments["x"];
			}
			if (tweenArguments.Contains("y"))
			{
				vector3s[1].y = (float)tweenArguments["y"];
			}
			if (tweenArguments.Contains("z"))
			{
				vector3s[1].z = (float)tweenArguments["z"];
			}
		}

		private void GenerateShakeRotationTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = thisTransform.eulerAngles;
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = (Vector3)tweenArguments["amount"];
				return;
			}
			if (tweenArguments.Contains("x"))
			{
				vector3s[1].x = (float)tweenArguments["x"];
			}
			if (tweenArguments.Contains("y"))
			{
				vector3s[1].y = (float)tweenArguments["y"];
			}
			if (tweenArguments.Contains("z"))
			{
				vector3s[1].z = (float)tweenArguments["z"];
			}
		}

		private void GeneratePunchPositionTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[5];
			vector3s[4] = thisTransform.eulerAngles;
			vector3s[0] = thisTransform.position;
			vector3s[1] = (vector3s[3] = Vector3.zero);
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = (Vector3)tweenArguments["amount"];
				return;
			}
			if (tweenArguments.Contains("x"))
			{
				vector3s[1].x = (float)tweenArguments["x"];
			}
			if (tweenArguments.Contains("y"))
			{
				vector3s[1].y = (float)tweenArguments["y"];
			}
			if (tweenArguments.Contains("z"))
			{
				vector3s[1].z = (float)tweenArguments["z"];
			}
		}

		private void GeneratePunchRotationTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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)
			vector3s = (Vector3[])(object)new Vector3[4];
			vector3s[0] = thisTransform.eulerAngles;
			vector3s[1] = (vector3s[3] = Vector3.zero);
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = (Vector3)tweenArguments["amount"];
				return;
			}
			if (tweenArguments.Contains("x"))
			{
				vector3s[1].x = (float)tweenArguments["x"];
			}
			if (tweenArguments.Contains("y"))
			{
				vector3s[1].y = (float)tweenArguments["y"];
			}
			if (tweenArguments.Contains("z"))
			{
				vector3s[1].z = (float)tweenArguments["z"];
			}
		}

		private void GeneratePunchScaleTargets()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			vector3s = (Vector3[])(object)new Vector3[3];
			vector3s[0] = thisTransform.localScale;
			vector3s[1] = Vector3.zero;
			if (tweenArguments.Contains("amount"))
			{
				vector3s[1] = (Vector3)tweenArguments["amount"];
				return;
			}
			if (tweenArguments.Contains("x"))
			{
				vector3s[1].x = (float)tweenArguments["x"];
			}
			if (tweenArguments.Contains("y"))
			{
				vector3s[1].y = (float)tweenArguments["y"];
			}
			if (tweenArguments.Contains("z"))
			{
				vector3s[1].z = (float)tweenArguments["z"];
			}
		}

		private void ApplyRectTargets()
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			((Rect)(ref rects[2])).x = ease(((Rect)(ref rects[0])).x, ((Rect)(ref rects[1])).x, percentage);
			((Rect)(ref rects[2])).y = ease(((Rect)(ref rects[0])).y, ((Rect)(ref rects[1])).y, percentage);
			((Rect)(ref rects[2])).width = ease(((Rect)(ref rects[0])).width, ((Rect)(ref rects[1])).width, percentage);
			((Rect)(ref rects[2])).height = ease(((Rect)(ref rects[0])).height, ((Rect)(ref rects[1])).height, percentage);
			tweenArguments["onupdateparams"] = rects[2];
			if ((double)percentage == 1.0)
			{
				tweenArguments["onupdateparams"] = rects[1];
			}
		}

		private void ApplyColorTargets()
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			colors[0, 2].r = ease(colors[0, 0].r, colors[0, 1].r, percentage);
			colors[0, 2].g = ease(colors[0, 0].g, colors[0, 1].g, percentage);
			colors[0, 2].b = ease(colors[0, 0].b, colors[0, 1].b, percentage);
			colors[0, 2].a = ease(colors[0, 0].a, colors[0, 1].a, percentage);
			tweenArguments["onupdateparams"] = colors[0, 2];
			if ((double)percentage == 1.0)
			{
				tweenArguments["onupdateparams"] = colors[0, 1];
			}
		}

		private void ApplyVector3Targets()
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			vector3s[2].x = ease(vector3s[0].x, vector3s[1].x, percentage);
			vector3s[2].y = ease(vector3s[0].y, vector3s[1].y, percentage);
			vector3s[2].z = ease(vector3s[0].z, vector3s[1].z, percentage);
			tweenArguments["onupdateparams"] = vector3s[2];
			if ((double)percentage == 1.0)
			{
				tweenArguments["onupdateparams"] = vector3s[1];
			}
		}

		private void ApplyVector2Targets()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			vector2s[2].x = ease(vector2s[0].x, vector2s[1].x, percentage);
			vector2s[2].y = ease(vector2s[0].y, vector2s[1].y, percentage);
			tweenArguments["onupdateparams"] = vector2s[2];
			if ((double)percentage == 1.0)
			{
				tweenArguments["onupdateparams"] = vector2s[1];
			}
		}

		private void ApplyFloatTargets()
		{
			floats[2] = ease(floats[0], floats[1], percentage);
			tweenArguments["onupdateparams"] = floats[2];
			if ((double)percentage == 1.0)
			{
				tweenArguments["onupdateparams"] = floats[1];
			}
		}

		private void ApplyColorToTargets()
		{
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < colors.GetLength(0); i++)
			{
				colors[i, 2].r = ease(colors[i, 0].r, colors[i, 1].r, percentage);
				colors[i, 2].g = ease(colors[i, 0].g, colors[i, 1].g, percentage);
				colors[i, 2].b = ease(colors[i, 0].b, colors[i, 1].b, percentage);
				colors[i, 2].a = ease(colors[i, 0].a, colors[i, 1].a, percentage);
			}
			if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<Renderer>()))
			{
				for (int j = 0; j < colors.GetLength(0); j++)
				{
					((Component)this).GetComponent<Renderer>().materials[j].SetColor(namedcolorvalue.ToString(), colors[j, 2]);
				}
			}
			else if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<Light>()))
			{
				((Component)this).GetComponent<Light>().color = colors[0, 2];
			}
			if ((double)percentage != 1.0)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<Renderer>()))
			{
				for (int k = 0; k < colors.GetLength(0); k++)
				{
					((Component)this).GetComponent<Renderer>().materials[k].SetColor(namedcolorvalue.ToString(), colors[k, 1]);
				}
			}
			else if (Object.op_Implicit((Object)(object)((Component)this).GetComponent<Light>()))
			{
				((Component)this).GetComponent<Light>().color = colors[0, 1];
			}
		}

		private void ApplyAudioToTargets()
		{
			vector2s[2].x = ease(vector2s[0].x, vector2s[1].x, percentage);
			vector2s[2].y = ease(vector2s[0].y, vector2s[1].y, percentage);
			audioSource.volume = vector2s[2].x;
			audioSource.pitch = vector2s[2].y;
			if ((double)percentage == 1.0)
			{
				audioSource.volume = vector2s[1].x;
				audioSource.pitch = vector2s[1].y;
			}
		}

		private void ApplyStabTargets()
		{
		}

		private void ApplyMoveToPathTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.position;
			float num = ease(0f, 1f, percentage);
			if (isLocal)
			{
				thisTransform.localPosition = path.Interp(Mathf.Clamp(num, 0f, 1f));
			}
			else
			{
				thisTransform.position = path.Interp(Mathf.Clamp(num, 0f, 1f));
			}
			if (tweenArguments.Contains("orienttopath") && (bool)tweenArguments["orienttopath"])
			{
				tweenArguments["looktarget"] = path.Interp(Mathf.Clamp(ease(0f, 1f, Mathf.Min(1f, percentage + ((!tweenArguments.Contains("lookahead")) ? Defaults.lookAhead : ((float)tweenArguments["lookahead"])))), 0f, 1f));
			}
			postUpdate = thisTransform.position;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MovePosition(Vector2.op_Implicit(postUpdate));
			}
		}

		private void ApplyMoveToTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.position;
			vector3s[2].x = ease(vector3s[0].x, vector3s[1].x, percentage);
			vector3s[2].y = ease(vector3s[0].y, vector3s[1].y, percentage);
			vector3s[2].z = ease(vector3s[0].z, vector3s[1].z, percentage);
			postUpdate = vector3s[2];
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MovePosition(Vector2.op_Implicit(postUpdate));
			}
		}

		private void GenerateTargets()
		{
			GenerateMoveToTargets();
			apply = ApplyMoveToTargets;
		}

		private void ApplyMoveByTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.position;
			Vector3 eulerAngles = default(Vector3);
			if (tweenArguments.Contains("looktarget"))
			{
				eulerAngles = thisTransform.eulerAngles;
				thisTransform.eulerAngles = vector3s[4];
			}
			vector3s[2].x = ease(vector3s[0].x, vector3s[1].x, percentage);
			vector3s[2].y = ease(vector3s[0].y, vector3s[1].y, percentage);
			vector3s[2].z = ease(vector3s[0].z, vector3s[1].z, percentage);
			thisTransform.Translate(vector3s[2] - vector3s[3], space);
			vector3s[3] = vector3s[2];
			if (tweenArguments.Contains("looktarget"))
			{
				thisTransform.eulerAngles = eulerAngles;
			}
			postUpdate = thisTransform.position;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MovePosition(Vector2.op_Implicit(postUpdate));
			}
		}

		private void ApplyScaleToTargets()
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			vector3s[2].x = ease(vector3s[0].x, vector3s[1].x, percentage);
			vector3s[2].y = ease(vector3s[0].y, vector3s[1].y, percentage);
			vector3s[2].z = ease(vector3s[0].z, vector3s[1].z, percentage);
			thisTransform.localScale = vector3s[2];
			if ((double)percentage == 1.0)
			{
				thisTransform.localScale = vector3s[1];
			}
		}

		private void ApplyLookToTargets()
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			vector3s[2].x = ease(vector3s[0].x, vector3s[1].x, percentage);
			vector3s[2].y = ease(vector3s[0].y, vector3s[1].y, percentage);
			vector3s[2].z = ease(vector3s[0].z, vector3s[1].z, percentage);
			if (isLocal)
			{
				thisTransform.localRotation = Quaternion.Euler(vector3s[2]);
			}
			else
			{
				thisTransform.rotation = Quaternion.Euler(vector3s[2]);
			}
		}

		private void ApplyRotateToTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: 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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.eulerAngles;
			vector3s[2].x = ease(vector3s[0].x, vector3s[1].x, percentage);
			vector3s[2].y = ease(vector3s[0].y, vector3s[1].y, percentage);
			vector3s[2].z = ease(vector3s[0].z, vector3s[1].z, percentage);
			if (isLocal)
			{
				thisTransform.localRotation = Quaternion.Euler(vector3s[2]);
			}
			else
			{
				thisTransform.rotation = Quaternion.Euler(vector3s[2]);
			}
			if ((double)percentage == 1.0)
			{
				if (isLocal)
				{
					thisTransform.localRotation = Quaternion.Euler(vector3s[1]);
				}
				else
				{
					thisTransform.rotation = Quaternion.Euler(vector3s[1]);
				}
			}
			postUpdate = thisTransform.eulerAngles;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MoveRotation(Quaternion.Euler(postUpdate));
			}
		}

		private void ApplyRotateAddTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.eulerAngles;
			vector3s[2].x = ease(vector3s[0].x, vector3s[1].x, percentage);
			vector3s[2].y = ease(vector3s[0].y, vector3s[1].y, percentage);
			vector3s[2].z = ease(vector3s[0].z, vector3s[1].z, percentage);
			thisTransform.Rotate(vector3s[2] - vector3s[3], space);
			vector3s[3] = vector3s[2];
			postUpdate = thisTransform.eulerAngles;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MoveRotation(Quaternion.Euler(postUpdate));
			}
		}

		private void ApplyShakePositionTargets()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = ((!isLocal) ? thisTransform.position : thisTransform.localPosition);
			Vector3 eulerAngles = default(Vector3);
			if (tweenArguments.Contains("looktarget"))
			{
				eulerAngles = thisTransform.eulerAngles;
				thisTransform.eulerAngles = vector3s[3];
			}
			if ((double)percentage == 0.0)
			{
				thisTransform.Translate(vector3s[1], space);
			}
			if (isLocal)
			{
				thisTransform.localPosition = vector3s[0];
			}
			else
			{
				thisTransform.position = vector3s[0];
			}
			float num = 1f - percentage;
			vector3s[2].x = Random.Range((0f - vector3s[1].x) * num, vector3s[1].x * num);
			vector3s[2].y = Random.Range((0f - vector3s[1].y) * num, vector3s[1].y * num);
			vector3s[2].z = Random.Range((0f - vector3s[1].z) * num, vector3s[1].z * num);
			if (isLocal)
			{
				Transform obj = thisTransform;
				obj.localPosition += vector3s[2];
			}
			else
			{
				Transform obj2 = thisTransform;
				obj2.position += vector3s[2];
			}
			if (tweenArguments.Contains("looktarget"))
			{
				thisTransform.eulerAngles = eulerAngles;
			}
			postUpdate = thisTransform.position;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MovePosition(Vector2.op_Implicit(postUpdate));
			}
		}

		private void ApplyShakeScaleTargets()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if ((double)percentage == 0.0)
			{
				thisTransform.localScale = vector3s[1];
			}
			thisTransform.localScale = vector3s[0];
			float num = 1f - percentage;
			vector3s[2].x = Random.Range((0f - vector3s[1].x) * num, vector3s[1].x * num);
			vector3s[2].y = Random.Range((0f - vector3s[1].y) * num, vector3s[1].y * num);
			vector3s[2].z = Random.Range((0f - vector3s[1].z) * num, vector3s[1].z * num);
			Transform obj = thisTransform;
			obj.localScale += vector3s[2];
		}

		private void ApplyShakeRotationTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.eulerAngles;
			if ((double)percentage == 0.0)
			{
				thisTransform.Rotate(vector3s[1], space);
			}
			thisTransform.eulerAngles = vector3s[0];
			float num = 1f - percentage;
			vector3s[2].x = Random.Range((0f - vector3s[1].x) * num, vector3s[1].x * num);
			vector3s[2].y = Random.Range((0f - vector3s[1].y) * num, vector3s[1].y * num);
			vector3s[2].z = Random.Range((0f - vector3s[1].z) * num, vector3s[1].z * num);
			thisTransform.Rotate(vector3s[2], space);
			postUpdate = thisTransform.eulerAngles;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MoveRotation(Quaternion.Euler(postUpdate));
			}
		}

		private void ApplyPunchPositionTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.position;
			Vector3 eulerAngles = default(Vector3);
			if (tweenArguments.Contains("looktarget"))
			{
				eulerAngles = thisTransform.eulerAngles;
				thisTransform.eulerAngles = vector3s[4];
			}
			if ((double)vector3s[1].x > 0.0)
			{
				vector3s[2].x = punch(vector3s[1].x, percentage);
			}
			else if ((double)vector3s[1].x < 0.0)
			{
				vector3s[2].x = 0f - punch(Mathf.Abs(vector3s[1].x), percentage);
			}
			if ((double)vector3s[1].y > 0.0)
			{
				vector3s[2].y = punch(vector3s[1].y, percentage);
			}
			else if ((double)vector3s[1].y < 0.0)
			{
				vector3s[2].y = 0f - punch(Mathf.Abs(vector3s[1].y), percentage);
			}
			if ((double)vector3s[1].z > 0.0)
			{
				vector3s[2].z = punch(vector3s[1].z, percentage);
			}
			else if ((double)vector3s[1].z < 0.0)
			{
				vector3s[2].z = 0f - punch(Mathf.Abs(vector3s[1].z), percentage);
			}
			thisTransform.Translate(vector3s[2] - vector3s[3], space);
			vector3s[3] = vector3s[2];
			if (tweenArguments.Contains("looktarget"))
			{
				thisTransform.eulerAngles = eulerAngles;
			}
			postUpdate = thisTransform.position;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MovePosition(Vector2.op_Implicit(postUpdate));
			}
		}

		private void ApplyPunchRotationTargets()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			preUpdate = thisTransform.eulerAngles;
			if ((double)vector3s[1].x > 0.0)
			{
				vector3s[2].x = punch(vector3s[1].x, percentage);
			}
			else if ((double)vector3s[1].x < 0.0)
			{
				vector3s[2].x = 0f - punch(Mathf.Abs(vector3s[1].x), percentage);
			}
			if ((double)vector3s[1].y > 0.0)
			{
				vector3s[2].y = punch(vector3s[1].y, percentage);
			}
			else if ((double)vector3s[1].y < 0.0)
			{
				vector3s[2].y = 0f - punch(Mathf.Abs(vector3s[1].y), percentage);
			}
			if ((double)vector3s[1].z > 0.0)
			{
				vector3s[2].z = punch(vector3s[1].z, percentage);
			}
			else if ((double)vector3s[1].z < 0.0)
			{
				vector3s[2].z = 0f - punch(Mathf.Abs(vector3s[1].z), percentage);
			}
			thisTransform.Rotate(vector3s[2] - vector3s[3], space);
			vector3s[3] = vector3s[2];
			postUpdate = thisTransform.eulerAngles;
			if (physics)
			{
				((Component)this).GetComponent<Rigidbody2D>().MoveRotation(Quaternion.Euler(postUpdate));
			}
		}

		private void ApplyPunchScaleTargets()
		{
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			if ((double)vector3s[1].x > 0.0)
			{
				vector3s[2].x = punch(vector3s[1].x, percentage);
			}
			else if ((double)vector3s[1].x < 0.0)
			{
				vector3s[2].x = 0f - punch(Mathf.Abs(vector3s[1].x), percentage);
			}
			if ((double)vector3s[1].y > 0.0)
			{
				vector3s[2].y = punch(vector3s[1].y, percentage);
			}
			else if ((double)vector3s[1].y < 0.0)
			{
				vector3s[2].y = 0f - punch(Mathf.Abs(vector3s[1].y), percentage);
			}
			if ((double)vector3s[1].z > 0.0)
			{
				vector3s[2].z = punch(vector3s[1].z, percentage);
			}
			else if ((double)vector3s[1].z < 0.0)
			{
				vector3s[2].z = 0f - punch(Mathf.Abs(vector3s[1].z), percentage);
			}
			thisTransform.localScale = vector3s[0] + vector3s[2];
		}

		[IteratorStateMachine(typeof(<TweenDelay>d__138))]
		private IEnumerator TweenDelay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TweenDelay>d__138(0)
			{
				<>4__this = this
			};
		}

		private void TweenStart()
		{
			CallBack("onstart");
			if (!loop)
			{
				ConflictCheck();
				GenerateTargets();
			}
			if (type == "stab")
			{
				audioSource.PlayOneShot(audioSource.clip);
			}
			if (type == "move" || type == "scale" || type == "rotate" || type == "punch" || type == "shake" || type == "curve" || type == "look")
			{
				EnableKinematic();
			}
			isRunning = true;
		}

		[IteratorStateMachine(typeof(<TweenRestart>d__140))]
		private IEnumerator TweenRestart()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TweenRestart>d__140(0)
			{
				<>4__this = this
			};
		}

		private void TweenUpdate()
		{
			apply();
			CallBack("onupdate");
			UpdatePercentage();
		}

		private void TweenComplete()
		{
			isRunning = false;
			percentage = (((double)percentage <= 0.5) ? 0f : 1f);
			apply();
			if (type == "value")
			{
				CallBack("onupdate");
			}
			if (loopType == LoopType.none)
			{
				Dispose();
			}
			else
			{
				TweenLoop();
			}
			CallBack("oncomplete");
		}

		private void TweenLoop()
		{
			DisableKinematic();
			switch (loopType)
			{
			case LoopType.loop:
				percentage = 0f;
				runningTime = 0f;
				apply();
				((MonoBehaviour)this).StartCoroutine("TweenRestart");
				break;
			case LoopType.pingPong:
				reverse = !reverse;
				runningTime = 0f;
				((MonoBehaviour)this).StartCoroutine("TweenRestart");
				break;
			}
		}

		public static Rect RectUpdate(Rect currentValue, Rect targetValue, float speed)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			return new Rect(FloatUpdate(((Rect)(ref currentValue)).x, ((Rect)(ref targetValue)).x, speed), FloatUpdate(((Rect)(ref currentValue)).y, ((Rect)(ref targetValue)).y, speed), FloatUpdate(((Rect)(ref currentValue)).width, ((Rect)(ref targetValue)).width, speed), FloatUpdate(((Rect)(ref currentValue)).height, ((Rect)(ref targetValue)).height, speed));
		}

		public static Vector3 Vector3Update(Vector3 currentValue, Vector3 targetValue, float speed)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = targetValue - currentValue;
			currentValue += val * speed * Time.deltaTime;
			return currentValue;
		}

		public static Vector2 Vector2Update(Vector2 currentValue, Vector2 targetValue, float speed)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = targetValue - currentValue;
			currentValue += val * speed * Time.deltaTime;
			return currentValue;
		}

		public static float FloatUpdate(float currentValue, float targetValue, float speed)
		{
			float num = targetValue - currentValue;
			currentValue += num * speed * Time.deltaTime;
			return currentValue;
		}

		public static void FadeUpdate(GameObject target, Hashtable args)
		{
			args["a"] = args["alpha"];
			ColorUpdate(target, args);
		}

		public static void FadeUpdate(GameObject target, float alpha, float time)
		{
			FadeUpdate(target, Hash("alpha", alpha, "time", time));
		}

		public static void ColorUpdate(GameObject target, Hashtable args)
		{
			//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)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			CleanArgs(args);
			Color[] array = (Color[])(object)new Color[4];
			if (!args.Contains("includechildren") || (bool)args["includechildren"])
			{
				foreach (Component item in target.transform)
				{
					Component val = item;
					ColorUpdate(val.gameObject, args);
				}
			}
			float num = ((!args.Contains("time")) ? Defaults.updateTime : ((float)args["time"] * Defaults.updateTimePercentage));
			if (Object.op_Implicit((Object)(object)target.GetComponent<Renderer>()))
			{
				array[0] = (array[1] = target.GetComponent<Renderer>().material.color);
			}
			else if (Object.op_Implicit((Object)(object)target.GetComponent<Light>()))
			{
				array[0] = (array[1] = target.GetComponent<Light>().color);
			}
			if (args.Contains("color"))
			{
				array[1] = (Color)args["color"];
			}
			else
			{
				if (args.Contains("r"))
				{
					array[1].r = (float)args["r"];
				}
				if (args.Contains("g"))
				{
					array[1].g = (float)args["g"];
				}
				if (args.Contains("b"))
				{
					array[1].b = (float)args["b"];
				}
				if (args.Contains("a"))
				{
					array[1].a = (float)args["a"];
				}
			}
			array[3].r = Mathf.SmoothDamp(array[0].r, array[1].r, ref array[2].r, num);
			array[3].g = Mathf.SmoothDamp(array[0].g, array[1].g, ref array[2].g, num);
			array[3].b = Mathf.SmoothDamp(array[0].b, array[1].b, ref array[2].b, num);
			array[3].a = Mathf.SmoothDamp(array[0].a, array[1].a, ref array[2].a, num);
			if (Object.op_Implicit((Object)(object)target.GetComponent<Renderer>()))
			{
				target.GetComponent<Renderer>().material.color = array[3];
			}
			else if (Object.op_Implicit((Object)(object)target.GetComponent<Light>()))
			{
				target.GetComponent<Light>().color = array[3];
			}
		}

		public static void ColorUpdate(GameObject target, Color color, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ColorUpdate(target, Hash("color", color, "time", time));
		}

		public static void AudioUpdate(GameObject target, Hashtable args)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			CleanArgs(args);
			Vector2[] array = (Vector2[])(object)new Vector2[4];
			float num = ((!args.Contains("time")) ? Defaults.updateTime : ((float)args["time"] * Defaults.updateTimePercentage));
			AudioSource val;
			if (args.Contains("audiosource"))
			{
				val = (AudioSource)args["audiosource"];
			}
			else
			{
				if (!Object.op_Implicit((Object)(object)target.GetComponent<AudioSource>()))
				{
					Debug.LogError((object)"iTween2d Error: AudioUpdate requires an AudioSource.");
					return;
				}
				val = target.GetComponent<AudioSource>();
			}
			array[0] = (array[1] = new Vector2(val.volume, val.pitch));
			if (args.Contains("volume"))
			{
				array[1].x = (float)args["volume"];
			}
			if (args.Contains("pitch"))
			{
				array[1].y = (float)args["pitch"];
			}
			array[3].x = Mathf.SmoothDampAngle(array[0].x, array[1].x, ref array[2].x, num);
			array[3].y = Mathf.SmoothDampAngle(array[0].y, array[1].y, ref array[2].y, num);
			val.volume = array[3].x;
			val.pitch = array[3].y;
		}

		public static void AudioUpdate(GameObject target, float volume, float pitch, float time)
		{
			AudioUpdate(target, Hash("volume", volume, "pitch", pitch, "time", time));
		}

		public static void RotateUpdate(GameObject target, Hashtable args)
		{
			//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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			CleanArgs(args);
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			Vector3 eulerAngles = target.transform.eulerAngles;
			float num = ((!args.Contains("time")) ? Defaults.updateTime : ((float)args["time"] * Defaults.updateTimePercentage));
			bool flag = ((!args.Contains("islocal")) ? Defaults.isLocal : ((bool)args["islocal"]));
			array[0] = ((!flag) ? target.transform.eulerAngles : target.transform.localEulerAngles);
			if (args.Contains("rotation"))
			{
				if (args["rotation"].GetType() == typeof(Transform))
				{
					Transform val = (Transform)args["rotation"];
					array[1] = val.eulerAngles;
				}
				else if (args["rotation"].GetType() == typeof(Vector3))
				{
					array[1] = (Vector3)args["rotation"];
				}
			}
			array[3].x = Mathf.SmoothDampAngle(array[0].x, array[1].x, ref array[2].x, num);
			array[3].y = Mathf.SmoothDampAngle(array[0].y, array[1].y, ref array[2].y, num);
			array[3].z = Mathf.SmoothDampAngle(array[0].z, array[1].z, ref array[2].z, num);
			if (flag)
			{
				target.transform.localEulerAngles = array[3];
			}
			else
			{
				target.transform.eulerAngles = array[3];
			}
			if ((Object)(object)target.GetComponent<Rigidbody2D>() != (Object)null)
			{
				Vector3 eulerAngles2 = target.transform.eulerAngles;
				target.GetComponent<Rigidbody2D>().MoveRotation(Quaternion.Euler(eulerAngles2));
			}
		}

		public static void RotateUpdate(GameObject target, Vector3 rotation, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			RotateUpdate(target, Hash("rotation", rotation, "time", time));
		}

		public static void ScaleUpdate(GameObject target, Hashtable args)
		{
			//IL_0044: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			CleanArgs(args);
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			float num = ((!args.Contains("time")) ? Defaults.updateTime : ((float)args["time"] * Defaults.updateTimePercentage));
			array[0] = (array[1] = target.transform.localScale);
			if (args.Contains("scale"))
			{
				if (args["scale"].GetType() == typeof(Transform))
				{
					Transform val = (Transform)args["scale"];
					array[1] = val.localScale;
				}
				else if (args["scale"].GetType() == typeof(Vector3))
				{
					array[1] = (Vector3)args["scale"];
				}
			}
			else
			{
				if (args.Contains("x"))
				{
					array[1].x = (float)args["x"];
				}
				if (args.Contains("y"))
				{
					array[1].y = (float)args["y"];
				}
				if (args.Contains("z"))
				{
					array[1].z = (float)args["z"];
				}
			}
			array[3].x = Mathf.SmoothDamp(array[0].x, array[1].x, ref array[2].x, num);
			array[3].y = Mathf.SmoothDamp(array[0].y, array[1].y, ref array[2].y, num);
			array[3].z = Mathf.SmoothDamp(array[0].z, array[1].z, ref array[2].z, num);
			target.transform.localScale = array[3];
		}

		public static void ScaleUpdate(GameObject target, Vector3 scale, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ScaleUpdate(target, Hash("scale", scale, "time", time));
		}

		public static void MoveUpdate(GameObject target, Hashtable args)
		{
			//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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_007d: 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_0080: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//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)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			CleanArgs(args);
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			Vector3 position = target.transform.position;
			float num = ((!args.Contains("time")) ? Defaults.updateTime : ((float)args["time"] * Defaults.updateTimePercentage));
			bool flag = ((!args.Contains("islocal")) ? Defaults.isLocal : ((bool)args["islocal"]));
			array[0] = ((!flag) ? (array[1] = target.transform.position) : (array[1] = target.transform.localPosition));
			if (args.Contains("position"))
			{
				if (args["position"].GetType() == typeof(Transform))
				{
					Transform val = (Transform)args["position"];
					array[1] = val.position;
				}
				else if (args["position"].GetType() == typeof(Vector3))
				{
					array[1] = (Vector3)args["position"];
				}
			}
			else
			{
				if (args.Contains("x"))
				{
					array[1].x = (float)args["x"];
				}
				if (args.Contains("y"))
				{
					array[1].y = (float)args["y"];
				}
				if (args.Contains("z"))
				{
					array[1].z = (float)args["z"];
				}
			}
			array[3].x = Mathf.SmoothDamp(array[0].x, array[1].x, ref array[2].x, num);
			array[3].y = Mathf.SmoothDamp(array[0].y, array[1].y, ref array[2].y, num);
			array[3].z = Mathf.SmoothDamp(array[0].z, array[1].z, ref array[2].z, num);
			if (args.Contains("orienttopath") && (bool)args["orienttopath"])
			{
				args["looktarget"] = array[3];
			}
			if (args.Contains("looktarget"))
			{
				LookUpdate(target, args);
			}
			if (flag)
			{
				target.transform.localPosition = array[3];
			}
			else
			{
				target.transform.position = array[3];
			}
			if ((Object)(object)target.GetComponent<Rigidbody2D>() != (Object)null)
			{
				Vector3 position2 = target.transform.position;
				target.GetComponent<Rigidbody2D>().MovePosition(Vector2.op_Implicit(position2));
			}
		}

		public static void MoveUpdate(GameObject target, Vector3 position, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			MoveUpdate(target, Hash("position", position, "time", time));
		}

		public static void LookUpdate(GameObject target, Hashtable args)
		{
			//IL_006d: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			CleanArgs(args);
			Vector3[] array = (Vector3[])(object)new Vector3[5];
			float num = (args.Contains("looktime") ? ((float)args["looktime"] * Defaults.updateTimePercentage) : ((!args.Contains("time")) ? Defaults.updateTime : ((float)args["time"] * 0.15f * Defaults.updateTimePercentage)));
			array[0] = target.transform.eulerAngles;
			if (args.Contains("looktarget"))
			{
				if (args["looktarget"].GetType() == typeof(Transform))
				{
					target.transform.LookAt((Transform)args["looktarget"], (Vector3)(((??)(Vector3?)args["up"]) ?? Defaults.up));
				}
				else if (args["looktarget"].GetType() == typeof(Vector3))
				{
					target.transform.LookAt((Vector3)args["looktarget"], (Vector3)(((??)(Vector3?)args["up"]) ?? Defaults.up));
				}
				array[1] = target.transform.eulerAngles;
				target.transform.eulerAngles = array[0];
				array[3].x = Mathf.SmoothDampAngle(array[0].x, array[1].x, ref array[2].x, num);
				array[3].y = Mathf.SmoothDampAngle(array[0].y, array[1].y, ref array[2].y, num);
				array[3].z = Mathf.SmoothDampAngle(array[0].z, array[1].z, ref array[2].z, num);
				target.transform.eulerAngles = array[3];
				if (args.Contains("axis"))
				{
					array[4] = target.transform.eulerAngles;
					switch ((string)args["axis"])
					{
					case "x":
						array[4].y = array[0].y;
						array[4].z = array[0].z;
						break;
					case "y":
						array[4].x = array[0].x;
						array[4].z = array[0].z;
						break;
					case "z":
						array[4].x = array[0].x;
						array[4].y = array[0].y;
						break;
					}
					target.transform.eulerAngles = array[4];
				}
			}
			else
			{
				Debug.LogError((object)"iTween2d Error: LookUpdate needs a 'looktarget' property!");
			}
		}

		public static void LookUpdate(GameObject target, Vector3 looktarget, float time)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			LookUpdate(target, Hash("looktarget", looktarget, "time", time));
		}

		public static float PathLength(Transform[] path)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
			float num = 0f;
			for (int i = 0; i < path.Length; i++)
			{
				array[i] = path[i].position;
			}
			Vector3[] pts = PathControlPointGenerator(array);
			Vector3 val = Interp(pts, 0f);
			int num2 = path.Length * 20;
			for (int j = 1; j <= num2; j++)
			{
				float t = (float)j / (float)num2;
				Vector3 val2 = Interp(pts, t);
				num += Vector3.Distance(val, val2);
				val = val2;
			}
			return num;
		}

		public static float PathLength(Vector3[] path)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			Vector3[] pts = PathControlPointGenerator(path);
			Vector3 val = Interp(pts, 0f);
			int num2 = path.Length * 20;
			for (int i = 1; i <= num2; i++)
			{
				float t = (float)i / (float)num2;
				Vector3 val2 = Interp(pts, t);
				num += Vector3.Distance(val, val2);
				val = val2;
			}
			return num;
		}

		public static void PutOnPath(GameObject target, Vector3[] path, float percent)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			target.transform.position = Interp(PathControlPointGenerator(path), percent);
		}

		public static void PutOnPath(Transform target, Vector3[] path, float percent)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			target.position = Interp(PathControlPointGenerator(path), percent);
		}

		public static void PutOnPath(GameObject target, Transform[] path, float percent)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
			for (int i = 0; i < path.Length; i++)
			{
				array[i] = path[i].position;
			}
			target.transform.position = Interp(PathControlPointGenerator(array), percent);
		}

		public static void PutOnPath(Transform target, Transform[] path, float percent)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
			for (int i = 0; i < path.Length; i++)
			{
				array[i] = path[i].position;
			}
			target.position = Interp(PathControlPointGenerator(array), percent);
		}

		public static Vector3 PointOnPath(Transform[] path, float percent)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
			for (int i = 0; i < path.Length; i++)
			{
				array[i] = path[i].position;
			}
			return Interp(PathControlPointGenerator(array), percent);
		}

		public static void DrawLine(Vector3[] line)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				DrawLineHelper(line, Defaults.color, "gizmos");
			}
		}

		public static void DrawLine(Vector3[] line, Color color)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				DrawLineHelper(line, color, "gizmos");
			}
		}

		public static void DrawLine(Transform[] line)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[line.Length];
				for (int i = 0; i < line.Length; i++)
				{
					array[i] = line[i].position;
				}
				DrawLineHelper(array, Defaults.color, "gizmos");
			}
		}

		public static void DrawLine(Transform[] line, Color color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[line.Length];
				for (int i = 0; i < line.Length; i++)
				{
					array[i] = line[i].position;
				}
				DrawLineHelper(array, color, "gizmos");
			}
		}

		public static void DrawLineGizmos(Vector3[] line)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				DrawLineHelper(line, Defaults.color, "gizmos");
			}
		}

		public static void DrawLineGizmos(Vector3[] line, Color color)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				DrawLineHelper(line, color, "gizmos");
			}
		}

		public static void DrawLineGizmos(Transform[] line)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[line.Length];
				for (int i = 0; i < line.Length; i++)
				{
					array[i] = line[i].position;
				}
				DrawLineHelper(array, Defaults.color, "gizmos");
			}
		}

		public static void DrawLineGizmos(Transform[] line, Color color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[line.Length];
				for (int i = 0; i < line.Length; i++)
				{
					array[i] = line[i].position;
				}
				DrawLineHelper(array, color, "gizmos");
			}
		}

		public static void DrawLineHandles(Vector3[] line)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				DrawLineHelper(line, Defaults.color, "handles");
			}
		}

		public static void DrawLineHandles(Vector3[] line, Color color)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				DrawLineHelper(line, color, "handles");
			}
		}

		public static void DrawLineHandles(Transform[] line)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[line.Length];
				for (int i = 0; i < line.Length; i++)
				{
					array[i] = line[i].position;
				}
				DrawLineHelper(array, Defaults.color, "handles");
			}
		}

		public static void DrawLineHandles(Transform[] line, Color color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (line.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[line.Length];
				for (int i = 0; i < line.Length; i++)
				{
					array[i] = line[i].position;
				}
				DrawLineHelper(array, color, "handles");
			}
		}

		public static Vector3 PointOnPath(Vector3[] path, float percent)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return Interp(PathControlPointGenerator(path), percent);
		}

		public static void DrawPath(Vector3[] path)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				DrawPathHelper(path, Defaults.color, "gizmos");
			}
		}

		public static void DrawPath(Vector3[] path, Color color)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				DrawPathHelper(path, color, "gizmos");
			}
		}

		public static void DrawPath(Transform[] path)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
				for (int i = 0; i < path.Length; i++)
				{
					array[i] = path[i].position;
				}
				DrawPathHelper(array, Defaults.color, "gizmos");
			}
		}

		public static void DrawPath(Transform[] path, Color color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
				for (int i = 0; i < path.Length; i++)
				{
					array[i] = path[i].position;
				}
				DrawPathHelper(array, color, "gizmos");
			}
		}

		public static void DrawPathGizmos(Vector3[] path)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				DrawPathHelper(path, Defaults.color, "gizmos");
			}
		}

		public static void DrawPathGizmos(Vector3[] path, Color color)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				DrawPathHelper(path, color, "gizmos");
			}
		}

		public static void DrawPathGizmos(Transform[] path)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
				for (int i = 0; i < path.Length; i++)
				{
					array[i] = path[i].position;
				}
				DrawPathHelper(array, Defaults.color, "gizmos");
			}
		}

		public static void DrawPathGizmos(Transform[] path, Color color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
				for (int i = 0; i < path.Length; i++)
				{
					array[i] = path[i].position;
				}
				DrawPathHelper(array, color, "gizmos");
			}
		}

		public static void DrawPathHandles(Vector3[] path)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				DrawPathHelper(path, Defaults.color, "handles");
			}
		}

		public static void DrawPathHandles(Vector3[] path, Color color)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				DrawPathHelper(path, color, "handles");
			}
		}

		public static void DrawPathHandles(Transform[] path)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
				for (int i = 0; i < path.Length; i++)
				{
					array[i] = path[i].position;
				}
				DrawPathHelper(array, Defaults.color, "handles");
			}
		}

		public static void DrawPathHandles(Transform[] path, Color color)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (path.Length != 0)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[path.Length];
				for (int i = 0; i < path.Length; i++)
				{
					array[i] = path[i].position;
				}
				DrawPathHelper(array, color, "handles");
			}
		}

		public static void Resume(GameObject target)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				Behaviour val = (Behaviour)array[i];
				val.enabled = true;
			}
		}

		public static void Resume(GameObject target, bool includechildren)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			Resume(target);
			if (!includechildren)
			{
				return;
			}
			foreach (Component item in target.transform)
			{
				Component val = item;
				Resume(val.gameObject, includechildren: true);
			}
		}

		public static void Resume(GameObject target, string type)
		{
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if ((iTween2d2.type + iTween2d2.method).Substring(0, type.Length).ToLower() == type.ToLower())
				{
					((Behaviour)iTween2d2).enabled = true;
				}
			}
		}

		public static void Resume(GameObject target, string type, bool includechildren)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if ((iTween2d2.type + iTween2d2.method).Substring(0, type.Length).ToLower() == type.ToLower())
				{
					((Behaviour)iTween2d2).enabled = true;
				}
			}
			if (!includechildren)
			{
				return;
			}
			foreach (Component item in target.transform)
			{
				Component val = item;
				Resume(val.gameObject, type, includechildren: true);
			}
		}

		public static void Resume()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			for (int i = 0; i < tweens.Count; i++)
			{
				Resume((GameObject)tweens[i]["target"]);
			}
		}

		public static void Resume(string type)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			ArrayList arrayList = new ArrayList();
			for (int i = 0; i < tweens.Count; i++)
			{
				GameObject value = (GameObject)tweens[i]["target"];
				arrayList.Insert(arrayList.Count, value);
			}
			for (int j = 0; j < arrayList.Count; j++)
			{
				Resume((GameObject)arrayList[j], type);
			}
		}

		public static void Pause(GameObject target)
		{
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if ((double)iTween2d2.delay > 0.0)
				{
					iTween2d2.delay -= (float)(Time.timeAsDouble - iTween2d2.delayStarted);
					((MonoBehaviour)iTween2d2).StopCoroutine("TweenDelay");
				}
				iTween2d2.isPaused = true;
				((Behaviour)iTween2d2).enabled = false;
			}
		}

		public static void Pause(GameObject target, bool includechildren)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			Pause(target);
			if (!includechildren)
			{
				return;
			}
			foreach (Component item in target.transform)
			{
				Component val = item;
				Pause(val.gameObject, includechildren: true);
			}
		}

		public static void Pause(GameObject target, string type)
		{
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if ((iTween2d2.type + iTween2d2.method).Substring(0, type.Length).ToLower() == type.ToLower())
				{
					if ((double)iTween2d2.delay > 0.0)
					{
						iTween2d2.delay -= (float)(Time.timeAsDouble - iTween2d2.delayStarted);
						((MonoBehaviour)iTween2d2).StopCoroutine("TweenDelay");
					}
					iTween2d2.isPaused = true;
					((Behaviour)iTween2d2).enabled = false;
				}
			}
		}

		public static void Pause(GameObject target, string type, bool includechildren)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if ((iTween2d2.type + iTween2d2.method).Substring(0, type.Length).ToLower() == type.ToLower())
				{
					if ((double)iTween2d2.delay > 0.0)
					{
						iTween2d2.delay -= (float)(Time.timeAsDouble - iTween2d2.delayStarted);
						((MonoBehaviour)iTween2d2).StopCoroutine("TweenDelay");
					}
					iTween2d2.isPaused = true;
					((Behaviour)iTween2d2).enabled = false;
				}
			}
			if (!includechildren)
			{
				return;
			}
			foreach (Component item in target.transform)
			{
				Component val = item;
				Pause(val.gameObject, type, includechildren: true);
			}
		}

		public static void Pause()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			for (int i = 0; i < tweens.Count; i++)
			{
				Pause((GameObject)tweens[i]["target"]);
			}
		}

		public static void Pause(string type)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			ArrayList arrayList = new ArrayList();
			for (int i = 0; i < tweens.Count; i++)
			{
				GameObject value = (GameObject)tweens[i]["target"];
				arrayList.Insert(arrayList.Count, value);
			}
			for (int j = 0; j < arrayList.Count; j++)
			{
				Pause((GameObject)arrayList[j], type);
			}
		}

		public static int Count()
		{
			return tweens.Count;
		}

		public static int Count(string type)
		{
			int num = 0;
			for (int i = 0; i < tweens.Count; i++)
			{
				Hashtable hashtable = tweens[i];
				if (((string)hashtable["type"] + (string)hashtable["method"]).Substring(0, type.Length).ToLower() == type.ToLower())
				{
					num++;
				}
			}
			return num;
		}

		public static int Count(GameObject target)
		{
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			return components.Length;
		}

		public static int Count(GameObject target, string type)
		{
			int num = 0;
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if ((iTween2d2.type + iTween2d2.method).Substring(0, type.Length).ToLower() == type.ToLower())
				{
					num++;
				}
			}
			return num;
		}

		public static void Stop()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			for (int i = 0; i < tweens.Count; i++)
			{
				Stop((GameObject)tweens[i]["target"]);
			}
			tweens.Clear();
		}

		public static void Stop(string type)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			ArrayList arrayList = new ArrayList();
			for (int i = 0; i < tweens.Count; i++)
			{
				GameObject value = (GameObject)tweens[i]["target"];
				arrayList.Insert(arrayList.Count, value);
			}
			for (int j = 0; j < arrayList.Count; j++)
			{
				Stop((GameObject)arrayList[j], type);
			}
		}

		public static void StopByName(string name)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			ArrayList arrayList = new ArrayList();
			for (int i = 0; i < tweens.Count; i++)
			{
				GameObject value = (GameObject)tweens[i]["target"];
				arrayList.Insert(arrayList.Count, value);
			}
			for (int j = 0; j < arrayList.Count; j++)
			{
				StopByName((GameObject)arrayList[j], name);
			}
		}

		public static void Stop(GameObject target)
		{
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				iTween2d2.Dispose();
			}
		}

		public static void Stop(GameObject target, bool includechildren)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			Stop(target);
			if (!includechildren)
			{
				return;
			}
			foreach (Component item in target.transform)
			{
				Component val = item;
				Stop(val.gameObject, includechildren: true);
			}
		}

		public static void Stop(GameObject target, string type)
		{
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if (iTween2d2.IsValid)
				{
					string text = iTween2d2.type + iTween2d2.method;
					try
					{
						text = text.Substring(0, type.Length);
					}
					catch (ArgumentOutOfRangeException ex)
					{
						Debug.LogError((object)("Error with iTween2d Stop. targetType=" + text + ", type=" + type));
						Debug.LogException((Exception)ex);
					}
					if (text.ToLower() == type.ToLower())
					{
						iTween2d2.Dispose();
					}
				}
			}
		}

		public static void StopByName(GameObject target, string name)
		{
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if (iTween2d2._name == name)
				{
					iTween2d2.Dispose();
				}
			}
		}

		public static void Stop(GameObject target, string type, bool includechildren)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if ((iTween2d2.type + iTween2d2.method).Substring(0, type.Length).ToLower() == type.ToLower())
				{
					iTween2d2.Dispose();
				}
			}
			if (!includechildren)
			{
				return;
			}
			foreach (Component item in target.transform)
			{
				Component val = item;
				Stop(val.gameObject, type, includechildren: true);
			}
		}

		public static void StopByName(GameObject target, string name, bool includechildren)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			Component[] components = (Component[])(object)target.GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if (iTween2d2._name == name)
				{
					iTween2d2.Dispose();
				}
			}
			if (!includechildren)
			{
				return;
			}
			foreach (Component item in target.transform)
			{
				Component val = item;
				StopByName(val.gameObject, name, includechildren: true);
			}
		}

		public static Hashtable Hash(params object[] args)
		{
			Hashtable hashtable = new Hashtable(args.Length / 2);
			if (args.Length % 2 != 0)
			{
				Debug.LogError((object)"Tween Error: Hash requires an even number of arguments!");
				return null;
			}
			for (int i = 0; i < args.Length - 1; i += 2)
			{
				hashtable.Add(args[i], args[i + 1]);
			}
			return hashtable;
		}

		private iTween2d(Hashtable h)
		{
			tweenArguments = h;
		}

		private void Awake()
		{
			thisTransform = ((Component)this).transform;
			RetrieveArgs();
			IsValid = true;
			lastRealTime = Time.realtimeSinceStartupAsDouble;
		}

		[IteratorStateMachine(typeof(<Start>d__226))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__226(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			if (!isRunning || physics)
			{
				return;
			}
			if (!reverse)
			{
				if ((double)percentage < 1.0)
				{
					TweenUpdate();
				}
				else
				{
					TweenComplete();
				}
			}
			else if ((double)percentage > 0.0)
			{
				TweenUpdate();
			}
			else
			{
				TweenComplete();
			}
		}

		private void FixedUpdate()
		{
			if (!isRunning || !physics)
			{
				return;
			}
			if (!reverse)
			{
				if ((double)percentage < 1.0)
				{
					TweenUpdate();
				}
				else
				{
					TweenComplete();
				}
			}
			else if ((double)percentage > 0.0)
			{
				TweenUpdate();
			}
			else
			{
				TweenComplete();
			}
		}

		private void LateUpdate()
		{
			if (tweenArguments.Contains("looktarget") && isRunning && (type == "move" || type == "shake" || type == "punch"))
			{
				LookUpdate(((Component)this).gameObject, tweenArguments);
			}
		}

		private void OnEnable()
		{
			if (isRunning)
			{
				EnableKinematic();
			}
			if (isPaused)
			{
				isPaused = false;
				if (!((double)delay <= 0.0))
				{
					wasPaused = true;
					ResumeDelay();
				}
			}
		}

		private void OnDisable()
		{
			DisableKinematic();
		}

		private static void DrawLineHelper(Vector3[] line, Color color, string method)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Gizmos.color = color;
			for (int i = 0; i < line.Length - 1; i++)
			{
				if (!(method == "gizmos"))
				{
					if (method == "handles")
					{
						Debug.LogError((object)"iTween2d Error: Drawing a line with Handles is temporarily disabled because of compatability issues with Unity 2.6!");
					}
				}
				else
				{
					Gizmos.DrawLine(line[i], line[i + 1]);
				}
			}
		}

		private static void DrawPathHelper(Vector3[] path, Color color, string method)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] pts = PathControlPointGenerator(path);
			Vector3 val = Interp(pts, 0f);
			Gizmos.color = color;
			int num = path.Length * 20;
			for (int i = 1; i <= num; i++)
			{
				float t = (float)i / (float)num;
				Vector3 val2 = Interp(pts, t);
				if (!(method == "gizmos"))
				{
					if (method == "handles")
					{
						Debug.LogError((object)"iTween2d Error: Drawing a path with Handles is temporarily disabled because of compatability issues with Unity 2.6!");
					}
				}
				else
				{
					Gizmos.DrawLine(val2, val);
				}
				val = val2;
			}
		}

		private static Vector3[] PathControlPointGenerator(Vector3[] path)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			int num = 2;
			Vector3[] array = (Vector3[])(object)new Vector3[path.Length + num];
			Array.Copy(path, 0, array, 1, path.Length);
			array[0] = array[1] + (array[1] - array[2]);
			array[^1] = array[^2] + (array[^2] - array[^3]);
			if (array[1] == array[^2])
			{
				Vector3[] array2 = (Vector3[])(object)new Vector3[array.Length];
				Array.Copy(array, array2, array.Length);
				array2[0] = array2[^3];
				array2[^1] = array2[2];
				array = (Vector3[])(object)new Vector3[array2.Length];
				Array.Copy(array2, array, array2.Length);
			}
			return array;
		}

		private static Vector3 Interp(Vector3[] pts, float t)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: 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)
			int num = pts.Length - 3;
			int num2 = Mathf.Min(Mathf.FloorToInt(t * (float)num), num - 1);
			float num3 = t * (float)num - (float)num2;
			Vector3 val = pts[num2];
			Vector3 val2 = pts[num2 + 1];
			Vector3 val3 = pts[num2 + 2];
			Vector3 val4 = pts[num2 + 3];
			return 0.5f * ((-val + 3f * val2 - 3f * val3 + val4) * (num3 * num3 * num3) + (2f * val - 5f * val2 + 4f * val3 - val4) * (num3 * num3) + (-val + val3) * num3 + 2f * val2);
		}

		public static void Launch(GameObject target, Hashtable args)
		{
			if (!args.Contains("id"))
			{
				args["id"] = GenerateID();
			}
			if (!args.Contains("target"))
			{
				args["target"] = target;
			}
			tweens.Insert(0, args);
			target.AddComponent<iTween2d>().id = (string)args["id"];
		}

		private static Hashtable CleanArgs(Hashtable args)
		{
			Hashtable hashtable = new Hashtable(args.Count);
			Hashtable hashtable2 = new Hashtable(args.Count);
			foreach (DictionaryEntry arg in args)
			{
				hashtable.Add(arg.Key, arg.Value);
			}
			foreach (DictionaryEntry item in hashtable)
			{
				if (item.Value.GetType() == typeof(int))
				{
					float num = (int)item.Value;
					args[item.Key] = num;
				}
				if (item.Value.GetType() == typeof(double))
				{
					float num2 = (float)(double)item.Value;
					args[item.Key] = num2;
				}
			}
			foreach (DictionaryEntry arg2 in args)
			{
				hashtable2.Add(arg2.Key.ToString().ToLower(), arg2.Value);
			}
			args = hashtable2;
			return args;
		}

		private static string GenerateID()
		{
			return Guid.NewGuid().ToString();
		}

		private void RetrieveArgs()
		{
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			foreach (Hashtable tween in tweens)
			{
				if ((Object)tween["target"] == (Object)(object)((Component)this).gameObject)
				{
					tweenArguments = tween;
					break;
				}
			}
			id = (string)tweenArguments["id"];
			type = (string)tweenArguments["type"];
			_name = (string)tweenArguments["name"];
			method = (string)tweenArguments["method"];
			time = ((!tweenArguments.Contains("time")) ? Defaults.time : ((float)tweenArguments["time"]));
			if ((Object)(object)((Component)this).GetComponent<Rigidbody2D>() != (Object)null)
			{
				physics = true;
			}
			delay = ((!tweenArguments.Contains("delay")) ? Defaults.delay : ((float)tweenArguments["delay"]));
			if (tweenArguments.Contains("namedcolorvalue"))
			{
				if (tweenArguments["namedcolorvalue"].GetType() == typeof(NamedValueColor))
				{
					namedcolorvalue = (NamedValueColor)tweenArguments["namedcolorvalue"];
				}
				else
				{
					try
					{
						namedcolorvalue = (NamedValueColor)Enum.Parse(typeof(NamedValueColor), (string)tweenArguments["namedcolorvalue"], ignoreCase: true);
					}
					catch
					{
						Debug.LogWarning((object)"iTween2d: Unsupported namedcolorvalue supplied! Default will be used.");
						namedcolorvalue = NamedValueColor._Color;
					}
				}
			}
			else
			{
				namedcolorvalue = Defaults.namedColorValue;
			}
			if (tweenArguments.Contains("looptype"))
			{
				if (tweenArguments["looptype"].GetType() == typeof(LoopType))
				{
					loopType = (LoopType)tweenArguments["looptype"];
				}
				else
				{
					try
					{
						loopType = (LoopType)Enum.Parse(typeof(LoopType), (string)tweenArguments["looptype"], ignoreCase: true);
					}
					catch
					{
						Debug.LogWarning((object)"iTween2d: Unsupported loopType supplied! Default will be used.");
						loopType = LoopType.none;
					}
				}
			}
			else
			{
				loopType = LoopType.none;
			}
			if (tweenArguments.Contains("easetype"))
			{
				if (tweenArguments["easetype"].GetType() == typeof(EaseType))
				{
					easeType = (EaseType)tweenArguments["easetype"];
				}
				else
				{
					try
					{
						easeType = (EaseType)Enum.Parse(typeof(EaseType), (string)tweenArguments["easetype"], ignoreCase: true);
					}
					catch
					{
						Debug.LogWarning((object)"iTween2d: Unsupported easeType supplied! Default will be used.");
						easeType = Defaults.easeType;
					}
				}
			}
			else
			{
				easeType = Defaults.easeType;
			}
			if (tweenArguments.Contains("space"))
			{
				if (tweenArguments["space"].GetType() == typeof(Space))
				{
					space = (Space)tweenArguments["space"];
				}
				else
				{
					try
					{
						space = (Space)Enum.Parse(typeof(Space), (string)tweenArguments["space"], ignoreCase: true);
					}
					catch
					{
						Debug.LogWarning((object)"iTween2d: Unsupported space supplied! Default will be used.");
						space = Defaults.space;
					}
				}
			}
			else
			{
				space = Defaults.space;
			}
			isLocal = ((!tweenArguments.Contains("islocal")) ? Defaults.isLocal : ((bool)tweenArguments["islocal"]));
			useRealTime = ((!tweenArguments.Contains("ignoretimescale")) ? Defaults.useRealTime : ((bool)tweenArguments["ignoretimescale"]));
			GetEasingFunction();
		}

		private void GetEasingFunction()
		{
			switch (easeType)
			{
			case EaseType.easeInQuad:
				ease = easeInQuad;
				break;
			case EaseType.easeOutQuad:
				ease = easeOutQuad;
				break;
			case EaseType.easeInOutQuad:
				ease = easeInOutQuad;
				break;
			case EaseType.easeInCubic:
				ease = easeInCubic;
				break;
			case EaseType.easeOutCubic:
				ease = easeOutCubic;
				break;
			case EaseType.easeInOutCubic:
				ease = easeInOutCubic;
				break;
			case EaseType.easeInQuart:
				ease = easeInQuart;
				break;
			case EaseType.easeOutQuart:
				ease = easeOutQuart;
				break;
			case EaseType.easeInOutQuart:
				ease = easeInOutQuart;
				break;
			case EaseType.easeInQuint:
				ease = easeInQuint;
				break;
			case EaseType.easeOutQuint:
				ease = easeOutQuint;
				break;
			case EaseType.easeInOutQuint:
				ease = easeInOutQuint;
				break;
			case EaseType.easeInSine:
				ease = easeInSine;
				break;
			case EaseType.easeOutSine:
				ease = easeOutSine;
				break;
			case EaseType.easeInOutSine:
				ease = easeInOutSine;
				break;
			case EaseType.easeInExpo:
				ease = easeInExpo;
				break;
			case EaseType.easeOutExpo:
				ease = easeOutExpo;
				break;
			case EaseType.easeInOutExpo:
				ease = easeInOutExpo;
				break;
			case EaseType.easeInCirc:
				ease = easeInCirc;
				break;
			case EaseType.easeOutCirc:
				ease = easeOutCirc;
				break;
			case EaseType.easeInOutCirc:
				ease = easeInOutCirc;
				break;
			case EaseType.linear:
				ease = linear;
				break;
			case EaseType.spring:
				ease = spring;
				break;
			case EaseType.easeInBounce:
				ease = easeInBounce;
				break;
			case EaseType.easeOutBounce:
				ease = easeOutBounce;
				break;
			case EaseType.easeInOutBounce:
				ease = easeInOutBounce;
				break;
			case EaseType.easeInBack:
				ease = easeInBack;
				break;
			case EaseType.easeOutBack:
				ease = easeOutBack;
				break;
			case EaseType.easeInOutBack:
				ease = easeInOutBack;
				break;
			case EaseType.easeInElastic:
				ease = easeInElastic;
				break;
			case EaseType.easeOutElastic:
				ease = easeOutElastic;
				break;
			case EaseType.easeInOutElastic:
				ease = easeInOutElastic;
				break;
			}
		}

		private void UpdatePercentage()
		{
			if (useRealTime)
			{
				runningTime += (float)(Time.realtimeSinceStartupAsDouble - lastRealTime);
			}
			else
			{
				runningTime += Time.deltaTime;
			}
			percentage = ((!reverse) ? (runningTime / time) : ((float)(1.0 - (double)runningTime / (double)time)));
			lastRealTime = Time.realtimeSinceStartupAsDouble;
		}

		private void CallBack(string callbackType)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (tweenArguments.Contains(callbackType) && !tweenArguments.Contains("ischild"))
			{
				GameObject val = (GameObject)((!tweenArguments.Contains(callbackType + "target")) ? ((object)((Component)this).gameObject) : ((object)(GameObject)tweenArguments[callbackType + "target"]));
				if (tweenArguments[callbackType].GetType() == typeof(string))
				{
					val.SendMessage((string)tweenArguments[callbackType], tweenArguments[callbackType + "params"], (SendMessageOptions)1);
					return;
				}
				Debug.LogError((object)"iTween2d Error: Callback method references must be passed as a String!");
				Object.Destroy((Object)(object)this);
			}
		}

		private void Dispose()
		{
			for (int i = 0; i < tweens.Count; i++)
			{
				if ((string)tweens[i]["id"] == id)
				{
					tweens.RemoveAt(i);
					break;
				}
			}
			Object.Destroy((Object)(object)this);
		}

		private void ConflictCheck()
		{
			Component[] components = (Component[])(object)((Component)this).GetComponents<iTween2d>();
			Component[] array = components;
			for (int i = 0; i < array.Length; i++)
			{
				iTween2d iTween2d2 = (iTween2d)(object)array[i];
				if (iTween2d2.type == "value")
				{
					break;
				}
				if (!iTween2d2.isRunning || !(iTween2d2.type == type))
				{
					continue;
				}
				if (iTween2d2.method != method)
				{
					break;
				}
				if (iTween2d2.tweenArguments.Count != tweenArguments.Count)
				{
					iTween2d2.Dispose();
					break;
				}
				foreach (DictionaryEntry tweenArgument in tweenArguments)
				{
					if (!iTween2d2.tweenArguments.Contains(tweenArgument.Key))
					{
						iTween2d2.Dispose();
						return;
					}
					if (!iTween2d2.tweenArguments[tweenArgument.Key].Equals(tweenArguments[tweenArgument.Key]) && (string)tweenArgument.Key != "id")
					{
						iTween2d2.Dispose();
						return;
					}
				}
				Dispose();
			}
		}

		private void EnableKinematic()
		{
		}

		private void DisableKinematic()
		{
		}

		private void ResumeDelay()
		{
			((MonoBehaviour)this).StartCoroutine("TweenDelay");
		}

		private float linear(float start, float end, float value)
		{
			return Mathf.Lerp(start, end, value);
		}

		private float clerp(float start, float end, float value)
		{
			float num = 0f;
			float num2 = 360f;
			float num3 = Mathf.Abs((float)(((double)num2 - (double)num) * 0.5));
			if ((double)end - (double)start < 0.0 - (double)num3)
			{
				float num4 = (num2 - start + end) * value;
				return start + num4;
			}
			if ((double)end - (double)start > (double)num3)
			{
				float num5 = (float)(0.0 - ((double)num2 - (double)end + (double)start)) * value;
				return start + num5;
			}
			return start + (end - start) * value;
		}

		private float spring(float start, float end, float value)
		{
			value = Mathf.Clamp01(value);
			value = (float)(((double)Mathf.Sin((float)((double)value * 3.1415927410125732 * (0.20000000298023224 + 2.5 * (double)value * (double)value * (double)value))) * (double)Mathf.Pow(1f - value, 2.2f) + (double)value) * (1.0 + 1.2000000476837158 * (1.0 - (double)value)));
			return start + (end - start) * value;
		}

		private float easeInQuad(float start, float end, float value)
		{
			end -= start;
			return end * value * value + start;
		}

		private float easeOutQuad(float start, float end, float value)
		{
			end -= start;
			return (float)((0.0 - (double)end) * (double)value * ((double)value - 2.0)) + start;
		}

		private float easeInOutQuad(float start, float end, float value)
		{
			value /= 0.5f;
			end -= start;
			if ((double)value < 1.0)
			{
				return end * 0.5f * value * value + start;
			}
			value -= 1f;
			return (float)((0.0 - (double)end) * 0.5 * ((double)value * ((double)value - 2.0) - 1.0)) + start;
		}

		private float easeInCubic(float start, float end, float value)
		{
			end -= start;
			return end * value * value * value + start;
		}

		private float easeOutCubic(float start, float end, float value)
		{
			value -= 1f;
			end -= start;
			return end * (float)((double)value * (double)value * (double)value + 1.0) + start;
		}

		private float easeInOutCubic(float start, float end, float value)
		{
			value /= 0.5f;
			end -= start;
			if ((double)value < 1.0)
			{
				return end * 0.5f * value * value * value + start;
			}
			value -= 2f;
			return (float)((double)end * 0.5 * ((double)value * (double)value * (double)value + 2.0)) + start;
		}

		private float easeInQuart(float start, float end, float value)
		{
			end -= start;
			return end * value * value * value * value + start;
		}

		private float easeOutQuart(float start, float end, float value)
		{
			value -= 1f;
			end -= start;
			return (float)((0.0 - (double)end) * ((double)value * (double)value * (double)value * (double)value - 1.0)) + start;
		}

		private float easeInOutQuart(float start, float end, float value)
		{
			value /= 0.5f;
			end -= start;
			if ((double)value < 1.0)
			{
				return end * 0.5f * value * value * value * value + start;
			}
			value -= 2f;
			return (float)((0.0 - (double)end) * 0.5 * ((double)value * (double)value * (double)value * (double)value - 2.0)) + start;
		}

		private float easeInQuint(float start, float end, float value)
		{
			end -= start;
			return end * value * value * value * value * value + start;
		}

		private float easeOutQuint(float start, float end, float value)
		{
			value -= 1f;
			end -= start;
			return end * (float)((double)value * (double)value * (double)value * (double)value * (double)value + 1.0) + start;
		}

		private float easeInOutQuint(float start, float end, float value)
		{
			value /= 0.5f;
			end -= start;
			if ((double)value < 1.0)
			{
				return end * 0.5f * value * value * value * value * value + start;
			}
			value -= 2f;
			return (float)((double)end * 0.5 * ((double)value * (double)value * (double)value * (double)value * (double)value + 2.0)) + start;
		}

		private float easeInSine(float start, float end, float value)
		{
			end -= start;
			return (0f - end) * Mathf.Cos(value * (MathF.PI / 2f)) + end + start;
		}

		private float easeOutSine(float start, float end, float value)
		{
			end -= start;
			return end * Mathf.Sin(value * (MathF.PI / 2f)) + start;
		}

		private float easeInOutSine(float start, float end, float value)
		{
			end -= start;
			return (float)((0.0 - (double)end) * 0.5 * ((double)Mathf.Cos(MathF.PI * value) - 1.0)) + start;
		}

		private float easeInExpo(float start, float end, float value)
		{
			end -= start;
			return end * Mathf.Pow(2f, (float)(10.0 * ((double)value - 1.0))) + start;
		}

		private float easeOutExpo(float start, float end, float value)
		{
			end -= start;
			return end * (float)(0.0 - (double)Mathf.Pow(2f, -10f * value) + 1.0) + start;
		}

		private float easeInOutExpo(float start, float end, float value)
		{
			value /= 0.5f;
			end -= start;
			if ((double)value < 1.0)
			{
				return end * 0.5f * Mathf.Pow(2f, (float)(10.0 * ((double)value - 1.0))) + start;
			}
			value -= 1f;
			return (float)((double)end * 0.5 * (0.0 - (double)Mathf.Pow(2f, -10f * value) + 2.0)) + start;
		}

		private float easeInCirc(float start, float end, float value)
		{
			end -= start;
			return (float)((0.0 - (double)end) * ((double)Mathf.Sqrt((float)(1.0 - (double)value * (double)value)) - 1.0)) + start;
		}

		private float easeOutCirc(float start, float end, float value)
		{
			value -= 1f;
			end -= start;
			return end * Mathf.Sqrt((float)(1.0 - (double)value * (double)value)) + start;
		}

		private float easeInOutCirc(float start, float end, float value)
		{
			value /= 0.5f;
			end -= start;
			if ((double)value < 1.0)
			{
				return (float)((0.0 - (double)end) * 0.5 * ((double)Mathf.Sqrt((float)(1.0 - (double)value * (double)value)) - 1.0)) + start;
			}
			value -= 2f;
			return (float)((double)end * 0.5 * ((double)Mathf.Sqrt((float)(1.0 - (double)value * (double)value)) + 1.0)) + start;
		}

		private float easeInBounce(float start, float end, float value)
		{
			end -= start;
			float num = 1f;
			return end - easeOutBounce(0f, end, num - value) + start;
		}

		private float easeOutBounce(float start, float end, float value)
		{
			value /= 1f;
			end -= start;
			if ((double)value < 0.3636363744735718)
			{
				return end * (7.5625f * value * value) + start;
			}
			if ((double)value < 0.7272727489471436)
			{
				value -= 0.54545456f;
				return end * (float)(7.5625 * (double)value * (double)value + 0.75) + start;
			}
			if ((double)value < 0.9090909090909091)
			{
				value -= 0.8181818f;
				return end * (float)(7.5625 * (double)value * (double)value + 0.9375) + start;
			}
			value -= 21f / 22f;
			return end * (float)(7.5625 * (double)value * (double)value + 63.0 / 64.0) + start;
		}

		private float easeInOutBounce(float start, float end, float value)
		{
			end -= start;
			float num = 1f;
			return ((double)value < (double)num * 0.5) ? (easeInBounce(0f, end, value * 2f) * 0.5f + start) : ((float)((double)easeOutBounce(0f, end, value * 2f - num) * 0.5 + (double)end * 0.5) + start);
		}

		private float easeInBack(float start, float end, float value)
		{
			end -= start;
			value /= 1f;
			float num = 1.70158f;
			return (float)((double)end * (double)value * (double)value * (((double)num + 1.0) * (double)value - (double)num)) + start;
		}

		private float easeOutBack(float start, float end, float value)
		{
			float num = 1.70158f;
			end -= start;
			value -= 1f;
			return end * (float)((double)value * (double)value * (((double)num + 1.0) * (double)value + (double)num) + 1.0) + start;
		}

		private float easeInOutBack(float start, float end, float value)
		{
			float num = 1.70158f;
			end -= start;
			value /= 0.5f;
			if ((double)value < 1.0)
			{
				float num2 = num * 1.525f;
				return (float)((double)end * 0.5 * ((double)value * (double)value * (((double)num2 + 1.0) * (double)value - (double)num2))) + start;
			}
			value -= 2f;
			float num3 = num * 1.525f;
			return (float)((double)end * 0.5 * ((double)value * (double)value * (((double)num3 + 1.0) * (double)value + (double)num3) + 2.0)) + start;
		}

		private float punch(float amplitude, float value)
		{
			if ((double)value == 0.0 || (double)value == 1.0)
			{
				return 0f;
			}
			float num = 0.3f;
			float num2 = num / (MathF.PI * 2f) * Mathf.Asin(0f);
			return amplitude * Mathf.Pow(2f, -10f * value) * Mathf.Sin((float)(((double)value * 1.0 - (double)num2) * 6.2831854820251465) / num);
		}

		private float easeInElastic(float start, float end, float value)
		{
			end -= start;
			float num = 1f;
			float num2 = num * 0.3f;
			float num3 = 0f;
			if ((double)value == 0.0)
			{
				return start;
			}
			if ((double)(value /= num) == 1.0)
			{
				return start + end;
			}
			float num4;
			if ((double)num3 == 0.0 || (double)num3 < (double)Mathf.Abs(end))
			{
				num3 = end;
				num4 = num2 / 4f;
			}
			else
			{
				num4 = num2 / (MathF.PI * 2f) * Mathf.Asin(end / num3);
			}
			return (float)(0.0 - (double)num3 * (double)Mathf.Pow(2f, 10f * (value -= 1f)) * (double)Mathf.Sin((float)(((double)value * (double)num - (double)num4) * 6.2831854820251465) / num2)) + start;
		}

		private float easeOutElastic(float start, float end, float value)
		{
			end -= start;
			float num = 1f;
			float num2 = num * 0.3f;
			float num3 = 0f;
			if ((double)value == 0.0)
			{
				return start;
			}
			if ((double)(value /= num) == 1.0)
			{
				return start + end;
			}
			float num4;
			if ((double)num3 == 0.0 || (double)num3 < (double)Mathf.Abs(end))
			{
				num3 = end;
				num4 = num2 * 0.25f;
			}
			else
			{
				num4 = num2 / (MathF.PI * 2f) * Mathf.Asin(end / num3);
			}
			return num3 * Mathf.Pow(2f, -10f * value) * Mathf.Sin((float)(((double)value * (double)num - (double)num4) * 6.2831854820251465) / num2) + end + start;
		}

		private float easeInOutElastic(float start, float end, float value)
		{
			end -= start;
			float num = 1f;
			float num2 = num * 0.3f;
			float num3 = 0f;
			if ((double)value == 0.0)
			{
				return start;
			}
			if ((double)(value /= num * 0.5f) == 2.0)
			{
				return start + end;
			}
			float num4;
			if ((double)num3 == 0.0 || (double)num3 < (double)Mathf.Abs(end))
			{
				num3 = end;
				num4 = num2 / 4f;
			}
			else
			{
				num4 = num2 / (MathF.PI * 2f) * Mathf.Asin(end / num3);
			}
			return ((double)value < 1.0) ? ((float)(-0.5 * ((double)num3 * (double)Mathf.Pow(2f, 10f * (value -= 1f)) * (double)Mathf.Sin((float)(((double)value * (double)num - (double)num4) * 6.2831854820251465) / num2))) + start) : ((float)((double)num3 * (double)Mathf.Pow(2f, -10f * (value -= 1f)) * (double)Mathf.Sin((float)(((double)value * (double)num - (double)num4) * 6.2831854820251465) / num2) * 0.5) + end + start);
		}
	}
	public static class MiscFixers
	{
		public class ColorLock : MonoBehaviour
		{
			public bool permanent;
		}

		private delegate string ToStringOrig(ref LocalisedString self, bool allowBlankText);

		public delegate void GetRespawnInfo(GameManager self, out string a, out string b);

		public class CustomBench : MonoBehaviour
		{
			private void Start()
			{
				float rotation2D = Extensions.GetRotation2D(((Component)this).transform);
				if (rotation2D != 0f)
				{
					((Component)this).gameObject.AddComponent<RestBenchTilt>().tilt = rotation2D;
				}
			}
		}

		public class MapperRing : TriggerActivator
		{
			private Collider2D _col2d;

			private bool _ground;

			public float x;

			public float y;

			private void Start()
			{
				_col2d = ((Component)this).GetComponent<Collider2D>();
				if (x != 0f || y != 0f)
				{
					Rigidbody2D component = ((Component)this).GetComponent<Rigidbody2D>();
					component.linearVelocityX = x;
					component.linearVelocityY = y;
					component.bodyType = (RigidbodyType2D)0;
					((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(true);
				}
			}

			private void OnCollisionEnter2D(Collision2D _)
			{
				if (CheckTouchingGround())
				{
					_ground = true;
					((Component)this).gameObject.BroadcastEvent("OnLand");
				}
				((Component)this).gameObject.BroadcastEvent("OnCollide");
			}

			private void OnCollisionExit2D(Collision2D _)
			{
				if (_ground && !CheckTouchingGround())
				{
					_ground = false;
					((Component)this).gameObject.BroadcastEvent("InAir");
				}
			}

			private void OnTriggerEnter2D(Collider2D other)
			{
				if (Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponentInChildren<NailSlash>()))
				{
					((Component)this).gameObject.BroadcastEvent("OnHit");
				}
			}

			public bool CheckTouchingGround()
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: 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_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)_col2d))
				{
					return true;
				}
				Bounds bounds = _col2d.bounds;
				double num = ((Bounds)(ref bounds)).min.x;
				bounds = _col2d.bounds;
				double num2 = ((Bounds)(ref bounds)).center.y;
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor((float)num, (float)num2);
				Bounds bounds2 = _col2d.bounds;
				Vector2 val2 = Vector2.op_Implicit(((Bounds)(ref bounds2)).center);
				Bounds bounds3 = _col2d.bounds;
				double num3 = ((Bounds)(ref bounds3)).max.x;
				bounds3 = _col2d.bounds;
				double num4 = ((Bounds)(ref bounds3)).center.y;
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor((float)num3, (float)num4);
				bounds3 = _col2d.bounds;
				float num5 = ((Bounds)(ref bounds3)).extents.y + 0.16f;
				Debug.DrawRay(Vector2.op_Implicit(val), Vector2.op_Implicit(Vector2.down), Color.yellow);
				Debug.DrawRay(Vector2.op_Implicit(val2), Vector2.op_Implicit(Vector2.down), Color.yellow);
				Debug.DrawRay(Vector2.op_Implicit(val3), Vector2.op_Implicit(Vector2.down), Color.yellow);
				RaycastHit2D val4 = Physics2D.Raycast(val, Vector2.down, num5, 256);
				RaycastHit2D val5 = Physics2D.Raycast(val2, Vector2.down, num5, 256);
				RaycastHit2D val6 = Physics2D.Raycast(val3, Vector2.down, num5, 256);
				return Object.op_Implicit((Object)(object)((RaycastHit2D)(ref val4)).collider) || Object.op_Implicit((Object)(object)((RaycastHit2D)(ref val5)).collider) || Object.op_Implicit((Object)(object)((RaycastHit2D)(ref val6)).collider);
			}
		}

		public class TriggerActivator : MonoBehaviour
		{
			public int layer;
		}

		private class MetronomeReactivator : MonoBehaviour
		{
			private void OnEnable()
			{
				MetronomePlat component = ((Component)this).gameObject.GetComponent<MetronomePlat>();
				if (((MonoBehaviour)component).didStart)
				{
					component.Start();
				}
			}
		}

		private class RotateOnSpawn : MonoBehaviour
		{
			public float rotation;

			private void Start()
			{
				Extensions.SetRotation2D(((Component)this).transform, rotation);
			}
		}

		public class WeaverLiftModifier : MonoBehaviour
		{
			public WeaverLift wl;

			public string target = string.Empty;

			public int mode;

			private bool _started;

			private void Update()
			{
				wl.cameraYPos = Extensions.GetPositionY(((Component)this).transform);
				if (_started)
				{
					return;
				}
				_started = true;
				if (!PlacementManager.Objects.TryGetValue(target, out var value))
				{
					return;
				}
				WeaverLift component = value.GetComponent<WeaverLift>();
				if (Object.op_Implicit((Object)(object)component))
				{
					if (mode == 0)
					{
						wl.liftUp = component;
					}
					else
					{
						wl.liftDown = component;
					}
				}
			}
		}

		public class Npc : MonoBehaviour
		{
			public string text = "Sample Text";
		}

		public class Garmond : Npc
		{
			private void Start()
			{
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)((Component)this).gameObject.transform.Find("Victory NPC")).gameObject, "Dialogue");
				fsm.GetState("Check").AddAction(delegate
				{
					fsm.SendEvent("REPEAT");
				}, 0, everyFrame: false);
				FsmState state = fsm.GetState("Talk A1");
				state.DisableAction(0);
				RunDialogue val = (RunDialogue)state.actions[1];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("Convo End").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class MrMushroom : Npc
		{
			private void Start()
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Check").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				fsm.GetState("Talk Type").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[1];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("Dialogue End").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class Loam : Npc
		{
			private void Start()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Behaviour");
				fsm.GetState("State?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class Shakra : Npc
		{
			private void Start()
			{
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Meet?").AddAction(delegate
				{
					fsm.SendEvent("MEET");
				}, 1, everyFrame: false);
				FsmState state = fsm.GetState("Act 3 Meet");
				state.DisableAction(0);
				RunDialogue val = (RunDialogue)state.actions[1];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("White Flower Check").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class ForgeDaughter : Npc
		{
			private void Start()
			{
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Expected O, but got Unknown
				((Component)((Component)this).transform.Find("Shop Prompt")).gameObject.SetActive(false);
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Already Met?").DisableAction(2);
				fsm.GetState("Demo?").AddAction(delegate
				{
					fsm.SendEvent("TRUE");
				}, 0, everyFrame: false);
				fsm.GetState("Talk State Demo").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				FsmState state = fsm.GetState("Repeat Demo");
				state.DisableAction(1);
				RunDialogue val = (RunDialogue)state.actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class BasicNpcFix : Npc
		{
			private void Start()
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				BasicNPC component = ((Component)this).GetComponent<BasicNPC>();
				LocalisedString repeatText = component.repeatText;
				repeatText.Sheet = "ArchitectMod";
				repeatText.Key = text;
				component.talkText = (LocalisedString[])(object)new LocalisedString[1] { repeatText };
				component.repeatText = repeatText;
				component.returnText = repeatText;
			}
		}

		public class SadPavo : Npc
		{
			private void Start()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Convo Check").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 1, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[2];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class Pavo : Npc
		{
			public float walkL;

			public float walkR;

			private void Start()
			{
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: 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_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Expected O, but got Unknown
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Convo").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 5, everyFrame: false);
				fsm.GetState("Check Twisted Bud Convo").AddAction(delegate
				{
					fsm.SendEvent("TRUE");
				}, 0, everyFrame: false);
				FsmState state = fsm.GetState("Twisted Bud Convo");
				state.DisableAction(0);
				RunDialogue val = (RunDialogue)state.actions[1];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
				FsmGameObject obj = fsm.FsmVariables.FindFsmGameObject("Turn Marker Left");
				GameObject val2 = new GameObject(((Object)this).name + " Turn Marker Left");
				val2.transform.position = ((Component)this).transform.position + new Vector3(0f - walkL, 0f);
				obj.Value = val2;
				FsmGameObject obj2 = fsm.FsmVariables.FindFsmGameObject("Turn Marker Right");
				GameObject val3 = new GameObject(((Object)this).name + " Turn Marker Right");
				val3.transform.position = ((Component)this).transform.position + new Vector3(walkR, 0f);
				obj2.Value = val3;
			}
		}

		public class Seth : Npc
		{
			private void Start()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Convo Check").AddAction(delegate
				{
					fsm.SendEvent("REPEAT");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class Zi : Npc
		{
			private void Start()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("State?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dlg").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}

			public void DoWake()
			{
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.SendEvent("SING");
				fsm.GetState("Inert").AddAction(delegate
				{
					fsm.SendEvent("SING");
				}, 0, everyFrame: false);
			}
		}

		public class Gilly : Npc
		{
			private void Start()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Behaviour");
				fsm.GetState("Convo Check").AddAction(delegate
				{
					fsm.SendEvent("REPEAT");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class MaskMaker : Npc
		{
			public string unmasked = "Sample Text";

			private void Start()
			{
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Expected O, but got Unknown
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Masked State?").AddAction(delegate
				{
					fsm.SendEvent("ALREADY MET");
				}, 0, everyFrame: false);
				fsm.GetState("Unmasked State?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				FsmState state = fsm.GetState("Already Met");
				state.DisableAction(0);
				state.DisableAction(1);
				RunDialogue val = (RunDialogue)state.actions[2];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				FsmState state2 = fsm.GetState("Unmasked Repeat");
				state2.DisableAction(0);
				state2.DisableAction(1);
				RunDialogue val2 = (RunDialogue)state2.actions[2];
				val2.Sheet = FsmString.op_Implicit("ArchitectMod");
				val2.Key = FsmString.op_Implicit(unmasked);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class Sherma : Npc
		{
			[CompilerGenerated]
			private sealed class <>c__DisplayClass1_0
			{
				public PlayMakerFSM fsm;

				public Sherma <>4__this;

				internal void <Start>b__0()
				{
					fsm.SendEvent("REPEAT");
				}

				internal void <Start>b__1()
				{
					fsm.SendEvent("WAKE");
				}

				internal void <Start>b__3()
				{
					fsm.SendEvent("READY");
				}

				internal void <Start>b__2()
				{
					((Component)<>4__this).gameObject.BroadcastEvent("OnFinish");
				}
			}

			[CompilerGenerated]
			private sealed class <>c__DisplayClass1_1
			{
				private sealed class <<Start>g__RepeatSoon|7>d : IEnumerator<object>, IEnumerator, IDisposable
				{
					private int <>1__state;

					private object <>2__current;

					public <>c__DisplayClass1_1 <>4__this;

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

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

					[DebuggerHidden]
					public <<Start>g__RepeatSoon|7>d(int <>1__state)
					{
						this.<>1__state = <>1__state;
					}

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

					private bool MoveNext()
					{
						//IL_0026: Unknown result type (might be due to invalid IL or missing references)
						//IL_0030: Expected O, but got Unknown
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>2__current = (object)new WaitForSeconds(0.2f);
							<>1__state = 1;
							return true;
						case 1:
							<>1__state = -1;
							<>4__this.anim.Play("Listen");
							<>4__this.CS$<>8__locals1.fsm.SendEvent("REPEAT");
							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 tk2dSpriteAnimator anim;

				public <>c__DisplayClass1_0 CS$<>8__locals1;

				internal void <Start>b__5()
				{
					((MonoBehaviour)CS$<>8__locals1.fsm).StartCoroutine(RepeatSoon());
					[IteratorStateMachine(typeof(<<Start>g__RepeatSoon|7>d))]
					IEnumerator RepeatSoon()
					{
						//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
						return new <<Start>g__RepeatSoon|7>d(0)
						{
							<>4__this = this
						};
					}
				}
			}

			public int startState;

			private void Start()
			{
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Expected O, but got Unknown
				<>c__DisplayClass1_0 CS$<>8__locals0 = new <>c__DisplayClass1_0();
				CS$<>8__locals0.<>4__this = this;
				CS$<>8__locals0.fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Conversation Control");
				FsmState state = CS$<>8__locals0.fsm.GetState("Asleep");
				FsmState state2 = CS$<>8__locals0.fsm.GetState("Choice");
				<>c__DisplayClass1_1 CS$<>8__locals1;
				if (startState == 1)
				{
					state.DisableAction(1);
					state2.AddAction(delegate
					{
						CS$<>8__locals0.fsm.SendEvent("REPEAT");
					}, 0, everyFrame: false);
				}
				else
				{
					state.AddAction(delegate
					{
						CS$<>8__locals0.fsm.SendEvent("WAKE");
					}, 0, everyFrame: false);
					if (startState == 2)
					{
						CS$<>8__locals1 = new <>c__DisplayClass1_1();
						CS$<>8__locals1.CS$<>8__locals1 = CS$<>8__locals0;
						FsmState state3 = CS$<>8__locals1.CS$<>8__locals1.fsm.GetState("Idle");
						state3.DisableAction(0);
						state3.DisableAction(1);
						state3.DisableAction(2);
						FsmState state4 = CS$<>8__locals1.CS$<>8__locals1.fsm.GetState("Sing");
						state3.AddAction(state4.actions[1], 1);
						state3.AddAction(state4.actions[2], 2);
						FsmState state5 = CS$<>8__locals1.CS$<>8__locals1.fsm.GetState("Sing End");
						state2.AddAction(state5.actions[0], 0);
						state5.AddAction(delegate
						{
							CS$<>8__locals1.CS$<>8__locals1.fsm.SendEvent("READY");
						}, 0, everyFrame: false);
						state3.transitions = state3.transitions.Where((FsmTransition i) => i.EventName != "SING").ToArray();
						for (int j = 1; j < 9; j++)
						{
							state2.DisableAction(j);
						}
						CS$<>8__locals1.anim = ((Component)this).GetComponent<tk2dSpriteAnimator>();
						state2.AddAction(delegate
						{
							((MonoBehaviour)CS$<>8__locals1.CS$<>8__locals1.fsm).StartCoroutine(RepeatSoon());
						}, 1, everyFrame: false);
						state2.transitions = state2.transitions.Where((FsmTransition o) => o.EventName == "REPEAT").ToArray();
					}
				}
				RunDialogue val = (RunDialogue)CS$<>8__locals0.fsm.GetState("Repeat").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				CS$<>8__locals0.fsm.GetState("End").AddAction(delegate
				{
					((Component)CS$<>8__locals0.<>4__this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
				[IteratorStateMachine(typeof(<>c__DisplayClass1_1.<<Start>g__RepeatSoon|7>d))]
				IEnumerator RepeatSoon()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass1_1.<<Start>g__RepeatSoon|7>d(0)
					{
						<>4__this = CS$<>8__locals1
					};
				}
			}
		}

		public class Pilby : Npc
		{
			private void Start()
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Behaviour");
				fsm.GetState("Location Check").AddAction(delegate
				{
					fsm.SendEvent("PILGRIMS REST");
				}, 0, everyFrame: false);
				fsm.GetState("Pilgrims Rest Choice").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat PR").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class Flick : Npc
		{
			private void Start()
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Talked?").AddAction(delegate
				{
					fsm.SendEvent("TRUE");
				}, 0, everyFrame: false);
				fsm.GetState("Delivery?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[2];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dlg").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class ArchitectNpc : Npc
		{
			private void Start()
			{
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Behaviour");
				fsm.GetState("Start Pos").AddAction(delegate
				{
					fsm.SendEvent("BOTTOM");
				}, 0, everyFrame: false);
				fsm.GetState("Met?").AddAction(delegate
				{
					fsm.SendEvent("FALSE");
				}, 0, everyFrame: false);
				fsm.GetState("Is Act 3?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				FsmState state = fsm.GetState("Meet Dlg");
				state.DisableAction(1);
				RunDialogue val = (RunDialogue)state.actions[2];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("Shop Up").AddAction(delegate
				{
					fsm.SendEvent("SHOP CLOSED");
				}, 0, everyFrame: false);
				fsm.GetState("Will Leave?").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
			}
		}

		public class Caretaker : Npc
		{
			public bool hail;

			private void Start()
			{
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Dialogue");
				fsm.GetState("Hail Hero?").AddAction(delegate
				{
					fsm.SendEvent(hail ? "HAIL" : "FINISHED");
				}, 0, everyFrame: false);
				fsm.GetState("Gone?").AddAction(delegate
				{
					fsm.SendEvent("FALSE");
				}, 0, everyFrame: false);
				fsm.GetState("Delivery?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				fsm.GetState("Will Offer Snare?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				fsm.GetState("Lv1 Meet?").AddAction(delegate
				{
					fsm.SendEvent("SPEAK");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Lv1 Meet").actions[1];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class Fleamaster : Npc
		{
			private void Start()
			{
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Outro Wave?").AddAction(delegate
				{
					fsm.SendEvent("CANCEL");
				}, 0, everyFrame: false);
				fsm.GetState("Intro Type").AddAction(delegate
				{
					fsm.SendEvent("INTRO");
				}, 0, everyFrame: false);
				fsm.GetState("Choice").AddAction(delegate
				{
					fsm.SendEvent("DECLINE");
				}, 0, everyFrame: false);
				fsm.GetState("Decline").AddAction(delegate
				{
					fsm.SendEvent("CONVO_END");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Intro").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class FrightenedSherma : Npc
		{
			private void Start()
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Conversation Control");
				fsm.fsm.globalTransitions = Array.Empty<FsmTransition>();
				FsmState state = fsm.GetState("Meet 1");
				state.DisableAction(0);
				RunDialogue val = (RunDialogue)state.actions[4];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				FsmState state2 = fsm.GetState("Turn Back");
				state2.DisableAction(0);
				state2.DisableAction(1);
				state2.DisableAction(2);
				state2.AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 4, everyFrame: false);
				fsm.GetState("Look Back").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				fsm.GetState("Meet 2").AddAction(delegate
				{
					fsm.SendEvent("CONVO_END");
				}, 0, everyFrame: false);
				FsmState state3 = fsm.GetState("End Dialogue");
				((EndDialogue)state3.actions[1]).ReturnControl.value = true;
				((ActivateInteractible)state3.actions[0]).Activate.value = true;
				state3.AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 2, everyFrame: false);
				state3.AddAction((FsmStateAction)new Wait
				{
					time = FsmFloat.op_Implicit(0.1f)
				}, 0);
				fsm.GetState("Start Battle").AddAction(delegate
				{
					fsm.SetState("Idle");
				}, 0, everyFrame: false);
			}
		}

		public class ShermaCaretaker : Npc
		{
			private void Start()
			{
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Start Asleep?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				fsm.GetState("Delivery?").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				fsm.GetState("Convo Check").AddAction(delegate
				{
					fsm.SendEvent("REPEAT");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Repeat").actions[2];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("End Dialogue").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class CustomFleaCounter : MonoBehaviour
		{
			private static readonly Color Gold = UI.MaxItemsTextColor;

			private static readonly Color Silver = new Color(0.45f, 0.45f, 0.5f);

			private static readonly Color Bronze = new Color(0.4f, 0.2f, 0.05f);

			private SimpleCounter _counter;

			public string header;

			public string footer;

			public int currentCount;

			public int gold = int.MaxValue;

			public int silver = int.MaxValue;

			public int bronze = int.MaxValue;

			public bool high;

			private Color _color;

			private Color _prevColor;

			private string _currentEvent;

			private void Awake()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				_counter = ((Component)this).GetComponent<SimpleCounter>();
				_counter.counterText.text = currentCount.ToString();
				Extensions.SetScale2D(((Component)this).transform, Vector2.one);
				RefreshGold(effect: false);
			}

			public void Increment()
			{
				currentCount++;
				_counter.counterText.text = currentCount.ToString();
				RefreshGold(effect: true);
			}

			public void SetValue(float value)
			{
				currentCount = Mathf.RoundToInt(value);
				_counter.counterText.text = currentCount.ToString();
				RefreshGold(effect: true);
			}

			public void Reset()
			{
				currentCount = 0;
				_counter.counterText.text = currentCount.ToString();
				RefreshGold(effect: true);
			}

			public void Decrement()
			{
				currentCount--;
				_counter.counterText.text = currentCount.ToString();
				RefreshGold(effect: true);
			}

			public void Announce()
			{
				TitleUtils.DisplayTitle(header, currentCount.ToString(), footer, 0);
			}

			private void RefreshGold(bool effect)
			{
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				if (high)
				{
					if (currentCount >= gold)
					{
						_color = Gold;
						_currentEvent = "OnGold";
					}
					else if (currentCount >= silver)
					{
						_color = Silver;
						_currentEvent = "OnSilver";
					}
					else if (currentCount >= bronze)
					{
						_color = Bronze;
						_currentEvent = "OnBronze";
					}
					else
					{
						_color = Color.white;
						_currentEvent = "OnWhite";
					}
				}
				else if (currentCount <= gold)
				{
					_color = Gold;
					_currentEvent = "OnGold";
				}
				else if (currentCount <= silver)
				{
					_color = Silver;
					_currentEvent = "OnSilver";
				}
				else if (currentCount <= bronze)
				{
					_color = Bronze;
					_currentEvent = "OnBronze";
				}
				else
				{
					_color = Color.white;
					_currentEvent = "OnWhite";
				}
				bool flag = false;
				if (_color != _prevColor && effect)
				{
					_counter.hitTargetEffect.SetActive(true);
					flag = true;
				}
				((Graphic)_counter.counterText).color = _color;
				_prevColor = _color;
				if (flag)
				{
					((Component)this).gameObject.BroadcastEvent(_currentEvent);
				}
			}

			private void OnEnable()
			{
				FleaCounters.Add(this);
			}

			private void OnDisable()
			{
				FleaCounters.Remove(this);
			}

			private void Update()
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				Extensions.SetPosition2D(((Component)this).gameObject.transform, new Vector2(0f, (float)FleaCounters.IndexOf(this) * 1.5f));
			}
		}

		public class Toll : MonoBehaviour
		{
			public string text = "Sample Text";

			private void Start()
			{
				PlayMakerFSM val = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Behaviour (special)");
				FsmState state = val.GetState("Confirm");
				state.DisableAction(0);
				FsmStateAction val2 = state.actions[1];
				FsmStateAction val3 = val2;
				FsmStateAction val4 = val3;
				DialogueYesNoV2 val5 = (DialogueYesNoV2)(object)((val4 is DialogueYesNoV2) ? val4 : null);
				if (val5 == null)
				{
					GetLocalisedString val6 = (GetLocalisedString)(object)((val4 is GetLocalisedString) ? val4 : null);
					if (val6 != null)
					{
						((FsmStateAction)val6).Enabled = false;
						FsmString str = val.FsmVariables.FindFsmString("Prompt Text Override");
						state.AddAction(delegate
						{
							str.Value = text;
						}, -1, everyFrame: false);
					}
				}
				else
				{
					val5.TranslationSheet = FsmString.op_Implicit("ArchitectMod");
					val5.TranslationKey = FsmString.op_Implicit(text);
				}
				FsmState state2 = val.GetState("Give Object");
				if (state2 != null)
				{
					state2.DisableAction(0);
					state2.AddAction(delegate
					{
						((Component)this).gameObject.BroadcastEvent("OnPay");
					}, 0, everyFrame: false);
				}
			}
		}

		public class Water : MonoBehaviour
		{
			private SurfaceWaterRegion _swr;

			private MaggotRegion _mr;

			private BoxCollider2D _col;

			private Vector3 _lastPos;

			public bool maggot;

			public bool abyss;

			private void Start()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				_swr = ((Component)this).GetComponent<SurfaceWaterRegion>();
				_mr = ((Component)this).GetComponent<MaggotRegion>();
				_col = ((Component)this).GetComponent<BoxCollider2D>();
				_lastPos = ((Component)this).transform.position;
				((Component)this).transform.GetChild(0).position = ((Component)this).transform.position + new Vector3(0f, 0.45f);
			}

			private void Update()
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				float num = Extensions.GetScaleY(((Component)this).transform) * _col.size.y;
				float num2 = num / 2f + 0.6f * Mathf.Min(Extensions.GetScaleY(((Component)this).transform) * _col.size.y, 1f);
				_swr.heroSurfaceY = Extensions.GetPositionY(((Component)this).transform) + num2;
				_mr.heroMaggotsYPos = Extensions.GetPositionY(HeroController.instance.transform) - Extensions.GetPositionY(((Component)this).transform) - 1f;
				ParticleSystem spawnedHeroMaggots = _mr.spawnedHeroMaggots;
				if (Object.op_Implicit((Object)(object)spawnedHeroMaggots))
				{
					((Component)spawnedHeroMaggots).transform.rotation = ((Component)this).transform.rotation;
					Extensions.SetPositionY(((Component)spawnedHeroMaggots).transform, ((Component)this).transform.position.y + _mr.heroMaggotsYPos);
				}
				if (_swr.isHeroInside && _lastPos != ((Component)this).transform.position)
				{
					Transform transform = HeroController.instance.transform;
					transform.position += ((Component)this).transform.position - _lastPos;
				}
				_lastPos = ((Component)this).transform.position;
			}
		}

		public class Dust : MonoBehaviour
		{
			public float time = 1f;
		}

		public class ThreadEffect : MonoBehaviour
		{
			public SilkPossession sp;
		}

		public class Silkfly : MonoBehaviour
		{
			public float xOffset = 5f;

			public float yOffset;
		}

		public class DisablingBreakable : MonoBehaviour
		{
			[CompilerGenerated]
			private sealed class <Reactivate>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public DisablingBreakable <>4__this;

				private Breakable <brk>5__1;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = null;
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						if (!Object.op_Implicit((Object)(object)<>4__this))
						{
							return false;
						}
						<brk>5__1 = ((Component)<>4__this).GetComponentInChildren<Breakable>(true);
						if (!Object.op_Implicit((Object)(object)<brk>5__1))
						{
							<brk>5__1 = ((Component)<>4__this).GetComponentInParent<Breakable>(true);
						}
						if (!<brk>5__1.isBroken)
						{
							return false;
						}
						<>4__this.target.SetActive(true);
						<>4__this.target.BroadcastEvent("OnBreak");
						Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
						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 GameObject target;

			private void OnDisable()
			{
				((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(Reactivate());
			}

			[IteratorStateMachine(typeof(<Reactivate>d__2))]
			private IEnumerator Reactivate()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Reactivate>d__2(0)
				{
					<>4__this = this
				};
			}
		}

		public class SilkCocoon : MonoBehaviour
		{
			public GameObject obj;

			private void OnEnable()
			{
				obj.BroadcastEvent("OnBreak");
			}
		}

		public class Bubble : MonoBehaviour
		{
			private string _scene = string.Empty;

			private void Start()
			{
				_scene = GameManager.instance.sceneName;
			}

			private void Update()
			{
				if (_scene != GameManager.instance.sceneName)
				{
					((Component)this).GetComponent<PlayMakerFSM>().SetState("Recycle");
					_scene = GameManager.instance.sceneName;
				}
			}
		}

		public class BounceFlea : MonoBehaviour
		{
			public bool isRight;

			public float distance = 10f;

			public float topYOffset = 2f;

			public float botYOffset = -2f;

			public bool flyAway = true;

			private float _startY;

			private FsmFloat _entryY;

			private FsmFloat _speed;

			private bool _quick;

			private PlayMakerFSM _fsm;

			private void Start()
			{
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				_startY = Extensions.GetPositionY(((Component)this).transform);
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Enter High").DisableAction(0);
				fsm.GetState("Enter Wave").DisableAction(0);
				FsmState state = fsm.GetState("Fly Past");
				((CheckXPosition)state.actions[2]).compareToOffset = FsmFloat.op_Implicit(-0.2f);
				((CheckXPosition)state.actions[3]).compareToOffset = FsmFloat.op_Implicit(0.2f);
				BoxCollider2D bc2d = ((Component)this).GetComponentInChildren<BoxCollider2D>(true);
				fsm.GetState("Choose Entry Side").AddAction(delegate
				{
					fsm.SendEvent(isRight ? "R" : "L");
					((Behaviour)bc2d).enabled = true;
				}, 0, everyFrame: false);
				_entryY = fsm.FsmVariables.FindFsmFloat("Entry Y");
				_speed = fsm.FsmVariables.FindFsmFloat("Fly Speed");
				fsm.FsmVariables.FindFsmFloat("Arena Edge L").Value = Extensions.GetPositionX(((Component)this).transform) + (isRight ? (0f - distance) : 0f);
				fsm.FsmVariables.FindFsmFloat("Arena Edge R").Value = Extensions.GetPositionX(((Component)this).transform) + (isRight ? 0f : distance);
				FsmState state2 = fsm.GetState("Fly Out");
				state2.AddAction(delegate
				{
					((Behaviour)bc2d).enabled = false;
				}, 0, everyFrame: false);
				FsmTransition val = fsm.GetState("Tink").transitions.First((FsmTransition e) => e.EventName == "END");
				val.toState = (flyAway ? "Fly Out" : "Fly Past");
				val.toFsmState = (flyAway ? state2 : fsm.GetState("Fly Past"));
				PlayMakerFSM val2 = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Wave Control");
				FsmFloat botY = val2.FsmVariables.FindFsmFloat("Bot Y");
				FsmFloat topY = val2.FsmVariables.FindFsmFloat("Top Y");
				val2.GetState("Start").AddAction(delegate
				{
					botY.Value = _entryY.Value + botYOffset;
					topY.Value = _entryY.Value + topYOffset;
				}, 2, everyFrame: false);
				fsm.GetState("Enter").DisableAction(2);
				fsm.GetState("Tink").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnHit");
					if (!flyAway)
					{
						fsm.SendEvent("END");
					}
				}, 0, everyFrame: false);
				fsm.GetState("Quickening Effects").AddAction(delegate
				{
					fsm.SendEvent(_quick ? "BUBBLES" : "FINISHED");
				}, 0, everyFrame: false);
				_fsm = fsm;
			}

			public void Fly(ScriptBlock block, string eName)
			{
				_entryY.Value = block.GetVariable<float>("Fly Y", _startY);
				_speed.Value = block.GetVariable<float>("Speed", 10);
				_quick = block.GetVariable<bool>("Quick");
				_fsm.SendEvent(eName);
			}
		}

		public class DodgeFlea : MonoBehaviour
		{
			private PlayMakerFSM _fsm;

			public int dir;

			public float dist = 50f;

			private FsmFloat _speed;

			private bool _quick;

			private Vector3 _startPos;

			private void Start()
			{
				//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_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Expected O, but got Unknown
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Expected O, but got Unknown
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Expected O, but got Unknown
				_startPos = ((Component)this).transform.position;
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Control");
				fsm.GetState("Set Speed").AddAction(delegate
				{
					fsm.SendEvent("FINISHED");
				}, 0, everyFrame: false);
				_speed = fsm.FsmVariables.FindFsmFloat("Charge Speed");
				RandomFloat val = (RandomFloat)fsm.GetState("Down").actions[0];
				val.min = (val.max = FsmFloat.op_Implicit(Extensions.GetPositionY(((Component)this).transform)));
				FsmState state = fsm.GetState("Diag");
				RandomFloat val2 = (RandomFloat)state.actions[0];
				val2.min = (val2.max = FsmFloat.op_Implicit(Extensions.GetPositionY(((Component)this).transform)));
				state.AddAction(delegate
				{
					fsm.SendEvent((dir == 2) ? "L" : "R");
				}, 5, everyFrame: false);
				RandomFloat val3 = (RandomFloat)fsm.GetState("Charge L").actions[0];
				val3.min = (val3.max = FsmFloat.op_Implicit(Extensions.GetPositionX(((Component)this).transform)));
				FsmState state2 = fsm.GetState("Charge R");
				RandomFloat val4 = (RandomFloat)state2.actions[0];
				val4.min = (val4.max = FsmFloat.op_Implicit(Extensions.GetPositionX(((Component)this).transform)));
				state2.DisableAction(7);
				FsmBool quickened = fsm.FsmVariables.FindFsmBool("Quickened");
				fsm.GetState("Quickening Effects").AddAction(delegate
				{
					quickened.Value = _quick;
				}, 0, everyFrame: false);
				fsm.FsmVariables.FindFsmFloat("Arena Bound L").Value = Extensions.GetPositionX(((Component)this).transform) - dist - 5f;
				fsm.FsmVariables.FindFsmFloat("Arena Bound R").Value = Extensions.GetPositionX(((Component)this).transform) + dist + 5f;
				FsmFloat val5 = fsm.FsmVariables.FindFsmFloat("Arena Centre");
				float positionX = Extensions.GetPositionX(((Component)this).transform);
				int num = dir;
				if (1 == 0)
				{
				}
				float num2 = num switch
				{
					0 => (0f - dist) / 2f, 
					1 => dist / 2f, 
					_ => 0f, 
				};
				if (1 == 0)
				{
				}
				val5.Value = positionX + num2;
				fsm.FsmVariables.FindFsmFloat("Side Y Top").Value = Extensions.GetPositionY(((Component)this).transform);
				fsm.FsmVariables.FindFsmFloat("Side Y Top Low").Value = Extensions.GetPositionY(((Component)this).transform);
				fsm.FsmVariables.FindFsmFloat("Side Y Bot").Value = Extensions.GetPositionY(((Component)this).transform) - dist;
				fsm.GetState("Tink React").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnHit");
				}, 0, everyFrame: false);
				fsm.GetState("Charge").DisableAction(5);
				_fsm = fsm;
			}

			public void Fly(ScriptBlock block)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				((Component)this).transform.position = _startPos;
				_speed.Value = block.GetVariable<float>("Speed", 20);
				_quick = block.GetVariable<bool>("Quick");
				PlayMakerFSM fsm = _fsm;
				int num = dir;
				if (1 == 0)
				{
				}
				string text = num switch
				{
					0 => "CHARGE L", 
					1 => "CHARGE R", 
					2 => "DIAG", 
					3 => "DIAG", 
					_ => "DOWN", 
				};
				if (1 == 0)
				{
				}
				fsm.SendEvent(text);
			}
		}

		public class MushroomTablet : Npc
		{
			private void Start()
			{
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				PlayMakerFSM fsm = FSMUtility.LocateMyFSM(((Component)this).gameObject, "Inspection");
				FsmState state = fsm.GetState("Idle");
				state.DisableAction(0);
				state.DisableAction(1);
				fsm.GetState("Hornet Dialogue").AddAction(delegate
				{
					fsm.SendEvent("CONVO_END");
				}, 0, everyFrame: false);
				fsm.GetState("Begin Quest?").AddAction(delegate
				{
					fsm.SendEvent("NO");
				}, 0, everyFrame: false);
				RunDialogue val = (RunDialogue)fsm.GetState("Weaver Dialogue").actions[0];
				val.Sheet = FsmString.op_Implicit("ArchitectMod");
				val.Key = FsmString.op_Implicit(text);
				fsm.GetState("Dialogue End No").AddAction(delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				}, 0, everyFrame: false);
			}
		}

		public class AllyWispRange : MonoBehaviour
		{
			public GameObject source;

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

			private void OnTriggerEnter2D(Collider2D other)
			{
				if (Object.op_Implicit((Object)(object)((Component)other).GetComponent<HealthManager>()))
				{
					_targets.Add(((Component)other).gameObject);
				}
			}

			private void OnTriggerExit2D(Collider2D other)
			{
				_targets.Remove(((Component)other).gameObject);
			}

			private void Update()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)source))
				{
					((Component)this).transform.position = source.transform.position;
				}
			}

			public GameObject GetObject()
			{
				_targets.RemoveAll((GameObject t) => !Object.op_Implicit((Object)(object)t));
				return _targets.OrderBy(delegate(GameObject t)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					Vector3 val = t.transform.position - ((Component)this).transform.position;
					return ((Vector3)(ref val)).magnitude;
				}).FirstOrDefault();
			}
		}

		public class AllyWisp : MonoBehaviour
		{
			public AllyWispRange range;
		}

		public class KeepInactive : MonoBehaviour
		{
			private void Update()
			{
				((Component)this).gameObject.SetActive(false);
			}
		}

		public static Material SpriteMaterial;

		private static readonly int ParticleLayer = LayerMask.NameToLayer("Particle");

		private static readonly int EnemyLayer = LayerMask.NameToLayer("Enemies");

		private static readonly List<CustomFleaCounter> FleaCounters = new List<CustomFleaCounter>();

		public static void Init()
		{
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			PreloadManager.RegisterPreload(new BasicPreload("Tut_02", "bone_plat_01", delegate(GameObject o)
			{
				SpriteMaterial = ((Renderer)o.GetComponent<SpriteRenderer>()).material;
			}));
			typeof(GameManager).Hook("GetRespawnInfo", (<>A{00000480}<GetRespawnInfo, GameManager, string, string>)delegate(GetRespawnInfo orig, GameManager self, out string scene, out string marker)
			{
				string respawnScene = self.playerData.respawnScene;
				string respawnMarkerName = self.playerData.respawnMarkerName;
				if (!string.IsNullOrEmpty(self.playerData.tempRespawnMarker))
				{
					self.playerData.tempRespawnMarker = "Dummy";
				}
				orig(self, out scene, out marker);
				if (string.IsNullOrEmpty(self.playerData.tempRespawnMarker))
				{
					scene = respawnScene;
					marker = respawnMarkerName;
				}
			});
			typeof(GameManager).Hook("FindEntryPoint", (Func<Func<GameManager, string, Scene, Vector2?>, GameManager, string, Scene, Vector2?>)delegate(Func<GameManager, string, Scene, Vector2?> orig, GameManager self, string name, Scene scene)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				Vector2? result3 = orig(self, name, scene);
				if (!result3.HasValue)
				{
					Scene activeScene2 = SceneManager.GetActiveScene();
					HazardRespawnMarker val4 = ((Scene)(ref activeScene2)).GetRootGameObjects().SelectMany((GameObject obj) => obj.GetComponentsInChildren<HazardRespawnMarker>(true)).FirstOrDefault();
					if (!Object.op_Implicit((Object)(object)val4))
					{
						return null;
					}
					return Vector2.op_Implicit(((Component)val4).transform.position);
				}
				return result3;
			});
			typeof(HeroController).Hook("LocateSpawnPoint", (Func<Func<HeroController, Transform>, HeroController, Transform>)delegate(Func<HeroController, Transform> orig, HeroController self)
			{
				//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)
				Transform val2 = orig(self);
				if (!Object.op_Implicit((Object)(object)val2))
				{
					Scene activeScene = SceneManager.GetActiveScene();
					HazardRespawnMarker val3 = ((Scene)(ref activeScene)).GetRootGameObjects().SelectMany((GameObject obj) => obj.GetComponentsInChildren<HazardRespawnMarker>(true)).FirstOrDefault();
					return Object.op_Implicit((Object)(object)val3) ? ((Component)val3).transform : null;
				}
				return val2;
			});
			typeof(GameCameras).Hook("Start", (Action<Action<GameCameras>, GameCameras>)delegate(Action<GameCameras> orig, GameCameras self)
			{
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				orig(self);
				GameObject gameObject = ((Component)((Component)self.hudCamera).transform.Find("In-game").Find("Anchor TL").Find("Hud Canvas Offset")
					.Find("Hud Canvas")
					.Find("Health")
					.Find("Health 2+")).gameObject;
				for (int i = 0; i < 90; i++)
				{
					int num = 11 + i;
					if (!Object.op_Implicit((Object)(object)gameObject.transform.parent.Find($"Health {num}")))
					{
						GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
						FSMUtility.LocateMyFSM(val, "health_display").FsmVariables.FindFsmInt("Health Number").Value = num;
						int num2 = num - 1;
						float num3 = -10.32f + 0.94f * (float)num2;
						val.transform.localPosition = new Vector3(num3, 7.7f, -2f);
					}
				}
			});
			typeof(WeaverLift).Hook("Teleport", (Action<Action<WeaverLift>, WeaverLift>)delegate(Action<WeaverLift> orig, WeaverLift self)
			{
				orig(self);
				((Component)self).gameObject.BroadcastEvent("OnActivate");
			});
			typeof(BasicNPC).Hook("OnEndDialogue", (Action<Action<BasicNPC>, BasicNPC>)delegate(Action<BasicNPC> orig, BasicNPC self)
			{
				((Component)self).gameObject.BroadcastEvent("OnFinish");
				orig(self);
			});
			typeof(MatchHeroFacing).Hook("DoMatch", (Action<Action<MatchHeroFacing>, MatchHeroFacing>)delegate(Action<MatchHeroFacing> orig, MatchHeroFacing self)
			{
				if (PreloadManager.HasPreloaded)
				{
					orig(self);
				}
			});
			typeof(LocalisedString).Hook("ToString", (<>F{00000008}<ToStringOrig, LocalisedString, bool, string>)delegate(ToStringOrig orig, ref LocalisedString self, bool allowBlankText)
			{
				string sheet = self.Sheet;
				if (1 == 0)
				{
				}
				string result2 = ((sheet == "ArchitectMod") ? SubstituteVars(self.Key) : ((!(sheet == "ArchitectMap")) ? orig(ref self, allowBlankText) : GlobalArchitectData.Instance.MapLabel));
				if (1 == 0)
				{
				}
				return result2;
			}, typeof(bool));
			typeof(DialogueBox).Hook("ParseTextForDialogueLines", (Func<Func<string, List<DialogueLine>>, string, List<DialogueLine>>)delegate(Func<string, List<DialogueLine>> orig, string text)
			{
				List<DialogueLine> source = orig(Regex.Replace(text.Replace("<br>", "\n"), "<(?!hpage|page\\b)(.*?)>", delegate(Match match)
				{
					string value = match.Groups[1].Value;
					return "%1open" + value + "%2close";
				}));
				return source.Select(delegate(DialogueLine line)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_004d: Unknown result type (might be due to invalid IL or missing references)
					DialogueLine result = default(DialogueLine);
					result.IsPlayer = line.IsPlayer;
					result.Text = line.Text.Replace("%1open", "<").Replace("%2close", ">");
					result.Event = line.Event;
					return result;
				}).ToList();
			});
			typeof(CustomSceneManager).Hook("UpdateAppearanceRegion", (Action<Action<CustomSceneManager, bool>, CustomSceneManager, bool>)delegate(Action<CustomSceneManager, bool> orig, CustomSceneManager self, bool forceImmediate)
			{
				try
				{
					orig(self, forceImmediate);
				}
				catch (ArgumentNullException)
				{
				}
				catch (NullReferenceException)
				{
				}
			});
			typeof(SimpleCounter).Hook("Start", (Action<Action<SimpleCounter>, SimpleCounter>)delegate(Action<SimpleCounter> orig, SimpleCounter self)
			{
				if (!Object.op_Implicit((Object)(object)((Component)self).GetComponent<CustomFleaCounter>()))
				{
					orig(self);
				}
			});
			new Hook((MethodBase)typeof(tk2dSprite).GetProperty("color").GetSetMethod(), (Delegate)(Action<Action<tk2dSprite, Color>, tk2dSprite, Color>)delegate(Action<tk2dSprite, Color> orig, tk2dSprite self, Color color)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				ColorLock componentInParent2 = ((Component)self).GetComponentInParent<ColorLock>();
				if (!Object.op_Implicit((Object)(object)componentInParent2) || !((Behaviour)componentInParent2).enabled)
				{
					orig(self, color);
				}
			});
			new Hook((MethodBase)typeof(SpriteRenderer).GetProperty("color").GetSetMethod(), (Delegate)(Action<Action<SpriteRenderer, Color>, SpriteRenderer, Color>)delegate(Action<SpriteRenderer, Color> orig, SpriteRenderer self, Color color)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				ColorLock componentInParent = ((Component)self).GetComponentInParent<ColorLock>();
				if (!Object.op_Implicit((Object)(object)componentInParent) || !((Behaviour)componentInParent).enabled)
				{
					orig(self, color);
				}
			});
			HookUtils.OnFsmAwake = (Action<PlayMakerFSM>)Delegate.Combine(HookUtils.OnFsmAwake, (Action<PlayMakerFSM>)delegate(PlayMakerFSM fsm)
			{
				if (((Object)fsm).name == "door_act3_wakeUp")
				{
					fsm.GetState("Init").DisableAction(1);
				}
				if (EditManager.IsEditing && fsm.FsmName == "Detect Grab" && ((Object)fsm).name == "Tendril")
				{
					((Component)fsm).gameObject.SetActive(false);
				}
			});
			new Hook((MethodBase)typeof(MaggotRegion).GetProperty("IsActive").GetGetMethod(), (Delegate)(Func<Func<MaggotRegion, bool>, MaggotRegion, bool>)delegate(Func<MaggotRegion, bool> orig, MaggotRegion self)
			{
				Water component2 = ((Component)self).GetComponent<Water>();
				return Object.op_Implicit((Object)(object)component2) ? component2.maggot : orig(self);
			});
			new Hook((MethodBase)typeof(AbyssWater).GetProperty("IsActive", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true), (Delegate)(Func<Func<AbyssWater, bool>, AbyssWater, bool>)delegate(Func<AbyssWater, bool> orig, AbyssWater self)
			{
				Water component = ((Component)self).GetComponent<Water>();
				return Object.op_Implicit((Object)(object)component) ? component.abyss : orig(self);
			});
			if (typeof(ToolItemManager).GetField("_activeState", BindingFlags.Instance | BindingFlags.NonPublic) != null)
			{
				typeof(GameManager).Hook("EnterHero", new Action<Action<GameManager>, GameManager>(OnSceneLoad));
			}
		}

		private static void OnSceneLoad(Action<GameManager> orig, GameManager self)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			orig(self);
			if (self.entryGateName == "door_fastTravelExit" && !PlayerData.instance.defeatedBellBeast)
			{
				ToolItemManager._activeState = (ToolsActiveStates)0;
			}
		}

		public static string SubstituteVars(string txt)
		{
			return Regex.Replace(txt, "\\[\\[(.*?)\\]\\]", delegate(Match match)
			{
				string value = match.Groups[1].Value;
				return StringVarBlock.GetVar(value);
			});
		}

		public static void FixTollBench(GameObject obj)
		{
			((Component)obj.transform.GetChild(3).GetChild(1).GetChild(2)
				.GetChild(0)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			Object.DestroyImmediate((Object)(object)((Component)obj.transform.GetChild(4).GetChild(2)).gameObject);
			obj.AddComponent<CustomBench>();
		}

		public static void FixBench(GameObject obj)
		{
			Extensions.SetPositionZ(obj.transform, 0.009f);
			Object.DestroyImmediate((Object)(object)((Component)obj.transform.GetChild(2)).gameObject);
			obj.AddComponent<CustomBench>();
		}

		public static void FixSackBench(GameObject obj)
		{
			Extensions.SetPositionZ(obj.transform, 0.009f);
			obj.AddComponent<CustomBench>();
		}

		public static void AddBenchEvent(GameObject obj)
		{
			PlayMakerFSM val = obj.GetComponentsInChildren<PlayMakerFSM>().First((PlayMakerFSM o) => o.FsmName == "Bench Control");
			val.fsmTemplate = null;
			val.GetState("Start Rest Anim").AddAction(delegate
			{
				obj.BroadcastEvent("OnSit");
			}, 0, everyFrame: false);
			val.GetState("Get Off").AddAction(delegate
			{
				obj.BroadcastEvent("OnLeave");
			}, 0, everyFrame: false);
			val.GetState("Set Custom Wake Up?").AddAction(delegate
			{
				obj.BroadcastEvent("OnSpawnAt");
			}, 0, everyFrame: false);
		}

		public static void MarkRing(GameObject obj)
		{
			obj.AddComponent<MapperRing>();
			obj.RemoveComponent<DeactivateIfPlayerdataTrue>();
			obj.layer = ParticleLayer;
		}

		public static void FixKratt(GameObject obj)
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			Rigidbody2D body = obj.GetComponent<Rigidbody2D>();
			body.bodyType = (RigidbodyType2D)1;
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Wounded Behaviour");
			fsm.GetState("Init").DisableAction(2);
			fsm.GetState("Land").DisableAction(2);
			fsm.GetState("Reactivate").DisableAction(1);
			fsm.GetState("Spoken?").AddAction(delegate
			{
				fsm.SendEvent("YES");
			}, 0, everyFrame: false);
			fsm.GetState("Idle").AddAction(delegate
			{
				body.bodyType = (RigidbodyType2D)0;
			}, -1, everyFrame: false);
			obj.GetComponent<EnemyHitEffectsRegular>().ReceivedHitEffect += (ReceivedHitEffectDelegate)delegate
			{
				obj.BroadcastEvent("OnHit");
			};
			obj.AddComponent<TriggerActivator>();
		}

		public static void FixBreakable(GameObject obj)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Breakable componentInChildren = obj.GetComponentInChildren<Breakable>();
			componentInChildren.onBreak.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("FirstBreak");
				obj.BroadcastEvent("OnBreak");
			});
		}

		public static void FixLamp(GameObject obj)
		{
			((Component)obj.transform.GetChild(0)).gameObject.AddComponent<DisablingBreakable>().target = obj;
			obj.transform.GetChild(0).GetChild(2).SetAsFirstSibling();
		}

		public static void FixBigLamp(GameObject obj)
		{
			((Component)obj.transform.GetChild(0).GetChild(0)).gameObject.AddComponent<DisablingBreakable>().target = obj;
			Extensions.SetPositionZ(obj.transform, 0.05f);
			obj.transform.GetChild(0).GetChild(0).GetChild(2)
				.SetAsFirstSibling();
		}

		public static void FixRing(GameObject obj)
		{
			PlayMakerFSM componentInChildren = obj.GetComponentInChildren<PlayMakerFSM>();
			componentInChildren.fsmTemplate = null;
			componentInChildren.GetState("Grab Start").AddAction(delegate
			{
				obj.BroadcastEvent("OnGrab");
			}, 0, everyFrame: false);
			componentInChildren.GetState("Cooldown").AddAction(delegate
			{
				obj.BroadcastEvent("OnRelease");
			}, 0, everyFrame: false);
		}

		public static void FixPoleRing(GameObject obj)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			obj.transform.GetChild(0).GetChild(0).Translate(0f, -10.13f, 0f);
			obj.transform.GetChild(1).GetChild(1).localPosition = Vector3.zero;
			((Component)obj.transform.GetChild(1).GetChild(1)).gameObject.RemoveComponent<FollowTransform>();
		}

		public static void FixBellSprite(GameObject obj)
		{
			((Component)obj.transform.GetChild(1).GetChild(0).GetChild(0)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
		}

		public static void FixBellBaby(GameObject obj)
		{
			obj.AddComponent<TriggerActivator>();
			obj.layer = ParticleLayer;
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			FsmGameObject child = fsm.FsmVariables.FindFsmGameObject("Nearest Child");
			fsm.GetState("Idle").AddAction(delegate
			{
				if (!Object.op_Implicit((Object)(object)child.Value))
				{
					child.Value = ((Component)HeroController.instance).gameObject;
				}
			}, 2, everyFrame: false);
			FsmGameObject mother = fsm.FsmVariables.FindFsmGameObject("Mother");
			fsm.GetState("Wait for Mother").AddAction(delegate
			{
				mother.Value = ((Component)HeroController.instance).gameObject;
				fsm.SendEvent("MOTHER AWAKE");
			}, -1, everyFrame: false);
			fsm.GetState("Tink React").AddAction(delegate
			{
				obj.BroadcastEvent("OnHit");
			}, -1, everyFrame: false);
		}

		public static void FixMetronome(GameObject obj)
		{
			MetronomePlat component = obj.GetComponent<MetronomePlat>();
			component.ticker = obj.AddComponent<TimedTicker>();
			obj.AddComponent<MetronomeReactivator>();
		}

		public static void FixMemoryPlat(GameObject obj)
		{
			obj.transform.GetChild(2).GetChild(1).GetChild(2)
				.GetChild(1)
				.SetAsFirstSibling();
			Object.Destroy((Object)(object)((Component)obj.transform.GetChild(0)).gameObject);
		}

		public static void SetMetronomeTime(GameObject obj, float delay)
		{
			obj.GetComponent<TimedTicker>().tickDelay = delay;
		}

		public static void SetMetronomeDelay(GameObject obj, float delay)
		{
			obj.GetComponent<TimedTicker>().timeElapsed = 0f - delay;
		}

		public static void FixHoker(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Alt Pos?").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			FsmState state = fsm.GetState("Explode");
			state.DisableAction(5);
			state.AddAction(delegate
			{
				EnemyDeathEffects component = obj.GetComponent<EnemyDeathEffects>();
				component.EmitSound();
				bool flag = default(bool);
				component.EmitEffects(component.EmitCorpse((float?)90f, 1f, (AttackTypes)1, (NailElements)0, (GameObject)null, (Action<Transform>)null, ref flag));
				Object.Destroy((Object)(object)obj);
			}, -1, everyFrame: false);
		}

		public static void FixUpdraft(GameObject obj)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			((Component)obj.transform.GetChild(0)).gameObject.SetActive(false);
			Extensions.SetScale2D(obj.transform, new Vector2(1f, 1f));
		}

		public static void DelayRotation(GameObject obj, float rot)
		{
			obj.AddComponent<RotateOnSpawn>().rotation = rot;
		}

		public static void FixGarmond(GameObject obj)
		{
			//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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			obj.RemoveComponent<ConstrainPosition>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.fsmTemplate = null;
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("QUICK TARGET");
			}, 0, everyFrame: false);
			fsm.GetState("Black Thread?").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			GameObject val = new GameObject("Battle End Point");
			val.transform.position = obj.transform.position;
			GameObject endPoint = val;
			fsm.GetState("Wait An Additional Frame").AddAction(delegate
			{
				fsm.FsmVariables.FindFsmGameObject("Battle End Point").Value = endPoint;
			}, 0, everyFrame: false);
			fsm.GetState("Idle").DisableAction(8);
			fsm.GetState("Chase Target").DisableAction(29);
			obj.AddComponent<Garmond>();
		}

		public static void FixGarmondBoss(GameObject obj)
		{
			FixGarmond(obj);
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Dormant").AddAction(delegate
			{
				fsm.SendEvent("CITADEL REMEET");
			}, 0, everyFrame: false);
			fsm.GetState("Cit NPC").AddAction(delegate
			{
				fsm.SendEvent("BATTLE START");
			}, 0, everyFrame: false);
			fsm.GetState("Auto Target?").AddAction(delegate
			{
				fsm.FsmVariables.FindFsmGameObject("Target").value = ((Component)HeroController.instance).gameObject;
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Keep Bouncing?").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Music").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Death Land").transitions = Array.Empty<FsmTransition>();
			FsmState state = fsm.GetState("Enemy Roar");
			state.DisableAction(2);
			state.DisableAction(5);
			state.DisableAction(6);
			state.DisableAction(7);
			((Component)obj.transform.Find("Citadel Library NPC")).gameObject.SetActive(false);
		}

		public static void FixWeaverLift(GameObject obj)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00c1: Expected O, but got Unknown
			Extensions.SetPositionZ(obj.transform, -0.2807f);
			((Component)obj.transform.GetChild(7)).gameObject.AddComponent<PlaceableObject.SpriteSource>();
			for (int i = 1; i <= 6; i++)
			{
				((Component)obj.transform.GetChild(i)).gameObject.SetActive(false);
			}
			for (int j = 10; j <= 11; j++)
			{
				((Component)obj.transform.GetChild(j)).gameObject.SetActive(false);
			}
			((Component)obj.transform.GetChild(17)).gameObject.SetActive(false);
			WeaverLift component = obj.GetComponent<WeaverLift>();
			PersistentBoolItem val = obj.AddComponent<PersistentBoolItem>();
			PersistentBoolData val2 = new PersistentBoolData();
			((PersistentItemData<bool>)val2).Value = true;
			val.itemData = val2;
			component.isUnlockedTarget = val;
			obj.AddComponent<WeaverLiftModifier>().wl = component;
		}

		public static void FixBasicNpc(GameObject obj)
		{
			obj.AddComponent<BasicNpcFix>();
		}

		public static void FixForgeDaughter(GameObject obj)
		{
			Extensions.SetPositionZ(obj.transform, 0.006f);
			obj.AddComponent<ForgeDaughter>();
		}

		public static void FixPavo(GameObject obj)
		{
			EnemyFixers.KeepActive(obj);
			obj.AddComponent<Pavo>();
		}

		public static void FixSadPavo(GameObject obj)
		{
			EnemyFixers.KeepActive(obj);
			obj.AddComponent<SadPavo>();
		}

		public static void FixPinPilgrim(GameObject obj)
		{
			EnemyFixers.KeepActive(obj);
			Extensions.SetPositionZ(obj.transform, 0.006f);
			obj.AddComponent<BasicNpcFix>();
			((Component)obj.transform.GetChild(3)).gameObject.SetActive(false);
		}

		public static void FixSeth(GameObject obj)
		{
			((Behaviour)FSMUtility.LocateMyFSM(obj, "Location")).enabled = false;
			obj.AddComponent<Seth>();
		}

		public static void FixShakra(GameObject obj)
		{
			obj.AddComponent<Shakra>();
		}

		public static void FixZi(GameObject obj)
		{
			Extensions.SetPositionZ(obj.transform, 0.007f);
			obj.AddComponent<Zi>();
		}

		public static void FixSecondSentinelAlly(GameObject obj)
		{
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.fsmTemplate = null;
			fsm.GetState("Ally Setup").DisableAction(2);
			fsm.GetState("Ally Wake").AddAction(delegate
			{
				GameObject value = fsm.FsmVariables.FindFsmGameObject("Target Cursor").value;
				PlayMakerFSM val = FSMUtility.LocateMyFSM(value, "Control");
				FsmGameObject target = val.FsmVariables.FindFsmGameObject("Current Target");
				FsmState state = val.GetState("Get Target");
				state.DisableAction(0);
				state.AddAction(delegate
				{
					//IL_0082: Unknown result type (might be due to invalid IL or missing references)
					//IL_0097: Unknown result type (might be due to invalid IL or missing references)
					//IL_009c: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
					Collider2D val2 = (from h in Object.FindObjectsByType<Collider2D>((FindObjectsInactive)0, (FindObjectsSortMode)0)
						where (Object)(object)((Component)h).gameObject != (Object)(object)obj && ((Component)h).gameObject.layer == EnemyLayer
						select h).OrderBy(delegate(Collider2D h)
					{
						//IL_0006: 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_001b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0020: Unknown result type (might be due to invalid IL or missing references)
						Vector3 val4 = ((Component)h).transform.position - obj.transform.position;
						return ((Vector3)(ref val4)).sqrMagnitude;
					}).FirstOrDefault();
					if (Object.op_Implicit((Object)(object)val2))
					{
						Vector3 val3 = ((Component)val2).transform.position - obj.transform.position;
						if (((Vector3)(ref val3)).sqrMagnitude < 512f)
						{
							target.value = ((Component)val2).gameObject;
						}
					}
				}, 1, everyFrame: false);
			}, 5, everyFrame: false);
		}

		public static void FixSherma(GameObject obj)
		{
			obj.RemoveComponent<DeactivateIfPlayerdataTrue>();
			obj.AddComponent<Sherma>();
		}

		public static void FixLoam(GameObject obj)
		{
			Extensions.SetPositionZ(obj.transform, 0.006f);
			obj.AddComponent<Loam>();
		}

		public static void FixArchitect(GameObject obj)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Extensions.SetPositionZ(obj.transform, 0.006f);
			obj.GetComponentInChildren<BoxCollider2D>().size = new Vector2(7f, 2f);
			obj.GetComponent<InteractableBase>().interactLabel = (PromptLabels)1;
			obj.AddComponent<ArchitectNpc>();
		}

		public static void FixCaretaker(GameObject obj)
		{
			EnemyFixers.KeepActive(obj);
			obj.AddComponent<Caretaker>();
		}

		public static void FixFrightenedSherma(GameObject obj)
		{
			obj.AddComponent<FrightenedSherma>();
		}

		public static void FixShermaCaretaker(GameObject obj)
		{
			obj.AddComponent<ShermaCaretaker>();
		}

		public static void FixFleaCounter(GameObject obj)
		{
			((Component)obj.transform.GetChild(2)).gameObject.AddComponent<PngObject>();
			obj.AddComponent<CustomFleaCounter>();
		}

		public static void FixConfetti(GameObject obj)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			obj.AddComponent<ParticleObject>();
			ParticleSystem component = obj.GetComponent<ParticleSystem>();
			MainModule main = component.main;
			((MainModule)(ref main)).maxParticles = 100000;
			EmissionModule emission = component.emission;
			((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(0f);
		}

		public static void FixBilePlat(GameObject obj)
		{
			obj.transform.GetChild(1).SetAsFirstSibling();
		}

		public static void FixFleamaster(GameObject obj)
		{
			obj.AddComponent<Fleamaster>();
		}

		public static void FixChoirClapper(GameObject obj)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Init").DisableAction(0);
			fsm.GetState("Rest").AddAction(delegate
			{
				((Component)fsm).GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
				fsm.SetState("Roar End");
			}, 2, everyFrame: false);
			FsmBool bt = fsm.FsmVariables.FindFsmBool("Black Threaded");
			fsm.GetState("Walk").AddAction(delegate
			{
				if (!bt.value)
				{
					BlackThreadState component = obj.GetComponent<BlackThreadState>();
					if (Object.op_Implicit((Object)(object)component) && component.CheckIsBlackThreaded())
					{
						bt.value = true;
					}
				}
			}, 0, everyFrame: false);
			fsm.FsmVariables.FindFsmFloat("Ground Y").value = obj.transform.position.y;
		}

		public static void FixCoral(GameObject obj)
		{
			obj.SetActive(true);
			obj.GetComponent<ActivatingBase>().SetActive(true, true);
			obj.RemoveComponent<RandomlyFlipScale>();
			obj.RemoveComponent<RandomRotationDelay>();
		}

		public static void FixFlea(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Call Out");
			((NamedVariable)val.FsmVariables.FindFsmObject("Quest Target")).Clear();
			val.GetState("Rescue 2").AddAction(delegate
			{
				obj.BroadcastEvent("OnSave");
			}, -1, everyFrame: false);
		}

		public static void FixSpecialPngs(GameObject obj)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			obj.AddComponent<PngObject>().ignoreGlow = true;
			Extensions.SetScale2D(obj.transform, new Vector2(2f, 2f));
			Extensions.SetPositionZ(obj.transform, -0.1f);
			Extensions.SetRotation2D(obj.transform, 0f);
		}

		public static void FixPilby(GameObject obj)
		{
			obj.AddComponent<Pilby>();
		}

		public static void FixToll(GameObject obj)
		{
			obj.RemoveComponent<CurrencyCounterAppearRegion>();
			obj.AddComponent<Toll>();
		}

		public static void FixShamanShell(GameObject obj)
		{
			((Behaviour)obj.GetComponentInChildren<BoxCollider2D>()).enabled = true;
			Extensions.SetRotation2D(obj.transform, 0f);
			Extensions.SetPositionZ(obj.transform, 0.006f);
		}

		public static void FixStatue(GameObject obj)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			BreakableHolder component = obj.GetComponent<BreakableHolder>();
			component.Broken.AddListener((UnityAction)delegate
			{
				obj.BroadcastEvent("OnBreak");
			});
		}

		public static void FixFixerStatue(GameObject obj)
		{
			((Component)obj.transform.GetChild(1)).gameObject.SetActive(false);
			FixStatue(obj);
		}

		public static void FixDecoration(GameObject obj)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			obj.AddComponent<ParticleObject>();
			Extensions.SetScale2D(obj.transform, Vector2.one * 5f);
			Extensions.SetPositionZ(obj.transform, 0.006f);
		}

		public static void FixWebDecoration(GameObject obj)
		{
			FixDecoration(obj);
			FollowCamera val = obj.AddComponent<FollowCamera>();
			val.followX = true;
			val.followY = true;
		}

		public static void FixSnow(GameObject obj)
		{
			FsmVariables fsmVariables = FSMUtility.LocateMyFSM(obj, "FSM").FsmVariables;
			fsmVariables.FindFsmFloat("X Min").Value = -1000f;
			fsmVariables.FindFsmFloat("Y Min").Value = -1000f;
		}

		public static void FixGrindPlat(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.FsmVariables.FindFsmBool("Drop Self").Value = true;
			val.FsmVariables.FindFsmFloat("Drop Y").Value = Extensions.GetPositionY(obj.transform) - 5f;
		}

		public static void FixBreakableWall(GameObject obj)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "breakable_wall_v2");
			val.fsmTemplate = null;
			FsmState state = val.GetState("Idle");
			Trigger2dEvent val2 = (Trigger2dEvent)state.actions[2];
			ReceivedDamage val3 = (ReceivedDamage)state.actions[4];
			((ReceivedDamageBase)val3).sendEventHeavy = ((ReceivedDamageBase)val3).sendEvent;
			val2.sendEvent = ((ReceivedDamageBase)val3).sendEvent;
			FsmState state2 = val.GetState("Hit 2");
			ReceivedDamage val4 = (ReceivedDamage)state2.actions[2];
			((ReceivedDamageBase)val4).sendEventHeavy = ((ReceivedDamageBase)val4).sendEvent;
			((PersistentItem<bool>)(object)obj.GetComponent<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
			{
				if (value)
				{
					obj.BroadcastEvent("OnBreak");
					obj.BroadcastEvent("LoadedBroken");
				}
			};
			val.GetState("Break").AddAction(delegate
			{
				obj.BroadcastEvent("OnBreak");
				obj.BroadcastEvent("FirstBreak");
			}, -1, everyFrame: false);
		}

		public static void FocusFirstChild(GameObject obj)
		{
			obj.transform.GetChild(1).SetAsFirstSibling();
		}

		public static void FixGilly(GameObject obj)
		{
			EnemyFixers.KeepActive(obj);
			obj.AddComponent<Gilly>();
		}

		public static void FixMaskMaker(GameObject obj)
		{
			obj.AddComponent<MaskMaker>();
		}

		public static void FixWater(GameObject obj)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			obj.transform.localScale = Vector3.one;
			BoxCollider2D component = obj.GetComponent<BoxCollider2D>();
			BoxCollider2D component2 = ((Component)obj.transform.GetChild(0)).GetComponent<BoxCollider2D>();
			BoxCollider2D component3 = ((Component)obj.transform.GetChild(0).GetChild(0)).GetComponent<BoxCollider2D>();
			component.size = Vector2.one * 5f;
			component2.size = Vector2.one * 5f;
			component3.size = Vector2.one * 5f;
			((Collider2D)component).offset = Vector2.zero;
			((Collider2D)component2).offset = Vector2.zero;
			((Collider2D)component3).offset = Vector2.zero;
			obj.AddComponent<Water>();
		}

		public static void FixSpaArea(GameObject obj)
		{
			//IL_0007: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			obj.transform.localScale = Vector3.one;
			BoxCollider2D component = obj.GetComponent<BoxCollider2D>();
			component.size = Vector2.one * 5f;
			((Collider2D)component).offset = Vector2.zero;
			((Component)obj.transform.GetChild(5)).gameObject.SetActive(false);
		}

		public static void FixSongclavePilgrim(GameObject obj)
		{
			PlayMakerFSM[] components = obj.GetComponents<PlayMakerFSM>();
			foreach (PlayMakerFSM val in components)
			{
				((Behaviour)val).enabled = false;
			}
			EnemyFixers.KeepActive(obj);
			obj.AddComponent<BasicNpcFix>();
			obj.RemoveComponent<BasicNPCRepeatDialogueLeaveCondition>();
			obj.RemoveComponent<NPCEncounterStateController>();
		}

		public static void FixRotation(GameObject obj)
		{
			Extensions.SetRotation2D(obj.transform, 0f);
		}

		public static void FixDust(GameObject obj)
		{
			Extensions.SetRotation2D(obj.transform, 0f);
			obj.AddComponent<Dust>();
		}

		public static void FixThreadEffect(GameObject obj)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			SilkPossession componentInChildren = obj.GetComponentInChildren<SilkPossession>(true);
			componentInChildren.possessedEnemy = obj;
			obj.AddComponent<ThreadEffect>().sp = componentInChildren;
			obj.GetComponentInChildren<AudioSource>(true).mute = true;
			((Component)componentInChildren).transform.localPosition = Vector3.zero;
		}

		public static void FixBlackStrand(GameObject obj)
		{
			Extensions.SetRotation2D(obj.transform, 45f);
			Extensions.SetPositionZ(obj.transform, 0.009f);
		}

		public static void FixSilkfly(GameObject obj)
		{
			obj.RemoveComponent<RandomScale>();
			PlayMakerFSM fsm = FSMUtility.LocateMyFSM(obj, "Control");
			fsm.GetState("Pause").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			fsm.GetState("Spawn Buddies").AddAction(delegate
			{
				fsm.SendEvent("FINISHED");
			}, 0, everyFrame: false);
			Silkfly s = obj.AddComponent<Silkfly>();
			fsm.GetState("Start").AddAction(delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Expected O, but got Unknown
				GameObject val = new GameObject("[Architect] Silkfly Target");
				val.transform.position = obj.transform.position + new Vector3(s.xOffset, s.yOffset);
				GameObject value = val;
				fsm.FsmVariables.FindFsmGameObject("Correct Gate").Value = value;
			}, 0, everyFrame: false);
			fsm.GetState("Leave").AddAction(delegate
			{
				obj.BroadcastEvent("OnActivate");
			}, 0, everyFrame: false);
		}

		public static void FixDisabledBreakable(GameObject obj)
		{
			obj.AddComponent<DisablingBreakable>().target = obj;
		}

		public static void FixSilkeaterCocoon(GameObject obj)
		{
			((Component)obj.transform.Find("Break Effects")).gameObject.AddComponent<SilkCocoon>().obj = obj;
		}

		public static void FixChest(GameObject obj)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Chest Control");
			val.fsmTemplate = null;
			FsmState state = val.GetState("Spawn Items");
			FsmInt val2 = val.FsmVariables.FindFsmInt("Geo Large");
			FlingObjectsFromGlobalPoolV3 val3 = new FlingObjectsFromGlobalPoolV3();
			FsmArray val4 = new FsmArray();
			val4.values = new object[1] { Gameplay.LargeGeoPrefab };
			val3.GameObjects = val4;
			val3.SpawnPoint = val.FsmVariables.FindFsmGameObject("Self");
			val3.SpawnMin = val2;
			val3.SpawnMax = val2;
			val3.SpeedMin = FsmFloat.op_Implicit(25f);
			val3.SpeedMax = FsmFloat.op_Implicit(38f);
			val3.AngleMin = FsmFloat.op_Implicit(78f);
			val3.AngleMax = FsmFloat.op_Implicit(102f);
			val3.OriginVariationX = FsmFloat.op_Implicit(0f);
			val3.OriginVariationY = FsmFloat.op_Implicit(0f);
			val3.spreadFrames = FsmInt.op_Implicit(4);
			val3.Position = new FsmVector3
			{
				value = new Vector3(0.25f, 0.25f, 0f)
			};
			state.AddAction((FsmStateAction)(object)val3);
		}

		public static void FixBreakableWindow(GameObject obj)
		{
			FixBreakable(obj);
			((PersistentItem<bool>)(object)obj.GetComponent<PersistentBoolItem>()).OnSetSaveState += delegate(bool value)
			{
				if (value)
				{
					obj.BroadcastEvent("OnBreak");
					obj.BroadcastEvent("LoadedBroken");
				}
			};
		}

		public static void FixBubble(GameObject obj)
		{
			obj.AddComponent<Bubble>();
		}

		public static void FixQuietPilgrim(GameObject obj)
		{
			obj.AddComponent<BasicNpcFix>();
			EnemyFixers.KeepActive(obj);
		}

		public static void RotateCocoon(GameObject obj, float rot)
		{
			Extensions.SetRotation2D(obj.transform, rot);
			HealthCocoon component = obj.GetComponent<HealthCocoon>();
			FlingPrefab[] flingPrefabs = component.flingPrefabs;
			foreach (FlingPrefab val in flingPrefabs)
			{
				val.Prefab = Object.Instantiate<GameObject>(val.Prefab);
				val.Prefab.SetActive(false);
				Extensions.SetRotation2D(val.Prefab.transform, 0f - rot);
			}
		}

		public static void FixJuggleFlea(GameObject obj)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(obj, "Control");
			val.GetState("Enter L").DisableAction(0);
			val.GetState("Enter R").DisableAction(0);
			val.FsmVariables.FindFsmFloat("Entry X").Value = Extensions.GetPositionX(obj.transform);
			val.FsmVariables.FindFsmFloat("Entry Y").Value = Extensions.GetPositionY(obj.transform);
			val.FsmVariables.FindFsmFloat("Platform Max X").Value = Extensions.GetPositionX(obj.transform) + 8f;
			val.FsmVariables.FindFsmFloat("Platform Min X").Value = Extensions.GetPositionX(obj.transform) - 8f;
			val.FsmVariables.FindFsmFloat("Floor Y").Value = Extensions.GetPositionY(obj.transform) - 5f;
		}

		public static void AddComponent<T>(GameObject obj) where T : MonoBehaviour
		{
			obj.AddComponent<T>();
		}

		public static void FixTrobbiwork(GameObject obj)
		{
			((Behaviour)obj.GetComponent<Animator>()).enabled = false;
			obj.RemoveComponent<DeactivateAfterDelay>();
			((Component)obj.transform.GetChild(2)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(3)).gameObject.SetActive(false);
			((Component)obj.transform.GetChild(4)).gameObject.SetActive(false);
		}

		public static void FixAllyWisp(GameObject obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			GameObject val = new GameObject(((Object)obj).name + " Range");
			CircleCollider2D val2 = val.AddComponent<CircleCollider2D>();
			((Collider2D)val2).isTrigger = true;
			val2.radius = 10f;
			AllyWispRange aw = val.AddComponent<AllyWispRange>();
			aw.source = obj;
			obj.AddComponent<AllyWisp>().range = aw;
			PlayMakerFSM val3 = FSMUtility.LocateMyFSM(obj, "Control");
			FsmState state = val3.GetState("New Target");
			FsmState state2 = val3.GetState("Retry Target");
			state.DisableAction(0);
			state2.DisableAction(0);
			FsmGameObject target = val3.FsmVariables.FindFsmGameObject("Target");
			state.AddAction(delegate
			{
				target.Value = aw.GetObject();
			}, 0, everyFrame: false);
			state2.AddAction(delegate
			{
				target.Value = aw.GetObject();
			}, 0, everyFrame: false);
		}
	}
	public class SemiPersistentBool : MonoBehaviour
	{
		public bool semiPersistent;

		private void Start()
		{
			PersistentBoolItem component = ((Component)this).GetComponent<PersistentBoolItem>();
			PersistentIntItem component2 = ((Component)this).GetComponent<PersistentIntItem>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((PersistentItem<bool>)(object)component).ItemData.IsSemiPersistent = semiPersistent;
			}
			if (Object.op_Implicit((Object)(object)component2))
			{
				((PersistentItem<int>)(object)component2).ItemData.IsSemiPersistent = semiPersistent;
			}
		}
	}
}
namespace Architect.Behaviour.Custom
{
	public class Binoculars : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ReturnZoom>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Math.Abs(GameCameras.instance.tk2dCam.ZoomFactor - 1f) > 0.001f)
				{
					if (BinocularsActive)
					{
						return false;
					}
					GameCameras.instance.tk2dCam.ZoomFactor = Mathf.Lerp(GameCameras.instance.tk2dCam.ZoomFactor, 1f, 10f * Time.deltaTime);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				GameCameras.instance.tk2dCam.ZoomFactor = 1f;
				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 static bool BinocularsActive;

		public float speed = 20f;

		public float maxZoom = 2.5f;

		public float minZoom = 0.25f;

		public float startZoom = 1f;

		public Vector3 startOffset;

		private bool _active;

		private Vector3 _targetPos;

		private float _zoom;

		private Vector3 _playerPos;

		private void Update()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			if (!_active)
			{
				return;
			}
			HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
			if (((OneAxisInputControl)inputActions.Jump).WasPressed || GameManager.instance.isPaused)
			{
				BinocularsActive = false;
				_active = false;
				HeroController.instance.damageMode = (DamageMode)0;
				if (Extensions.IsNullOrEmpty<VignetteDisabler>((ICollection<VignetteDisabler>)VignetteDisabler.Disablers))
				{
					((Component)HeroController.instance.vignette).gameObject.SetActive(true);
				}
				HeroController.instance.RegainControl();
				((MonoBehaviour)this).StartCoroutine(ReturnZoom());
				((Component)this).gameObject.BroadcastEvent("OnStop");
				return;
			}
			float num = 0f;
			if (((OneAxisInputControl)inputActions.Up).IsPressed)
			{
				num += 1f;
			}
			if (((OneAxisInputControl)inputActions.Down).IsPressed)
			{
				num -= 1f;
			}
			float num2 = 0f;
			if (((OneAxisInputControl)inputActions.Right).IsPressed)
			{
				num2 += 1f;
			}
			if (((OneAxisInputControl)inputActions.Left).IsPressed)
			{
				num2 -= 1f;
			}
			float zoomFactor = GameCameras.instance.tk2dCam.ZoomFactor;
			_targetPos = CameraBorder.KeepWithinBounds(_targetPos + new Vector3(num2 * Time.deltaTime * speed / zoomFactor, num * Time.deltaTime * speed / zoomFactor, 0f));
			Transform transform = ((Component)GameCameras.instance.cameraController).transform;
			transform.position = Vector3.Lerp(transform.position, _targetPos, 9f * Time.deltaTime);
			_zoom = Mathf.Clamp(_zoom + Input.mouseScrollDelta.y / 20f, minZoom, maxZoom);
			HeroController.instance.transform.position = _playerPos;
			GameCameras.instance.tk2dCam.ZoomFactor = Mathf.Lerp(zoomFactor, _zoom, 15f * Time.deltaTime);
		}

		private void OnTriggerEnter2D(Collider2D other)
		{
			if (Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<NailSlash>()))
			{
				StartUsing();
			}
		}

		public static void Init()
		{
			typeof(CameraController).Hook("LateUpdate", (Action<Action<CameraController>, CameraController>)delegate(Action<CameraController> orig, CameraController self)
			{
				if (!BinocularsActive)
				{
					orig(self);
				}
			});
			typeof(HeroController).Hook("Move", (Action<Action<HeroController, float, bool>, HeroController, float, bool>)delegate(Action<HeroController, float, bool> orig, HeroController self, float moveDir, bool useInp)
			{
				if (!BinocularsActive)
				{
					orig(self, moveDir, useInp);
				}
			});
		}

		public void StartUsing()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			_zoom = startZoom;
			BinocularsActive = true;
			_active = true;
			HeroController.instance.damageMode = (DamageMode)2;
			((Component)HeroController.instance.vignette).gameObject.SetActive(false);
			HeroController.instance.RelinquishControl();
			_playerPos = HeroController.instance.transform.position;
			_targetPos = ((Component)GameCameras.instance.cameraController).transform.position + startOffset;
			((Component)this).gameObject.BroadcastEvent("OnStart");
		}

		[IteratorStateMachine(typeof(<ReturnZoom>d__14))]
		private static IEnumerator ReturnZoom()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReturnZoom>d__14(0);
		}
	}
	public class Bumper : SoundMaker, IHitResponder
	{
		public static readonly Sprite NormalIcon = ResourceUtils.LoadSpriteResource("Bumper.Normal.icon", (FilterMode)0, default(Vector4), 15f);

		public static readonly Sprite EvilIcon = ResourceUtils.LoadSpriteResource("Bumper.Evil.icon", (FilterMode)0, default(Vector4), 15f);

		private static AudioClip _hitNormal;

		private static AudioClip _hitEvil;

		private static readonly Sprite[][] Normal = LoadGroups("Bumper.Normal");

		private static readonly Sprite[][] Evil = LoadGroups("Bumper.Evil");

		private SpriteRenderer _renderer;

		private CircleCollider2D _col2d;

		private float _frame;

		private bool _evil;

		private int _stage;

		public static void Init()
		{
			ResourceUtils.LoadClipResource("Bumper.Normal.hit", delegate(AudioClip clip)
			{
				_hitNormal = clip;
			});
			ResourceUtils.LoadClipResource("Bumper.Evil.hit", delegate(AudioClip clip)
			{
				_hitEvil = clip;
			});
		}

		private static Sprite[][] LoadGroups(string path)
		{
			return new Sprite[4][]
			{
				LoadSprites(path + ".Idle", 32),
				LoadSprites(path + ".Hit", 9),
				LoadSprites(path + ".Off", 1),
				LoadSprites(path + ".On", 3)
			};
		}

		private static Sprite[] LoadSprites(string path, int count)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Sprite[] array = (Sprite[])(object)new Sprite[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = ResourceUtils.LoadSpriteResource($"{path}.f{i}", (FilterMode)0, default(Vector4), 15f);
			}
			return array;
		}

		public override void Awake()
		{
			base.Awake();
			_renderer = ((Component)this).GetComponent<SpriteRenderer>();
			_col2d = ((Component)this).GetComponent<CircleCollider2D>();
		}

		public void SetEvil(bool newEvil)
		{
			_evil = newEvil;
			((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(_evil);
		}

		private void Update()
		{
			Sprite[] array = (_evil ? Evil : Normal)[_stage];
			_renderer.sprite = array[Mathf.FloorToInt(_frame)];
			_frame += Time.deltaTime * 15f;
			if (_frame >= (float)array.Length)
			{
				switch (_stage)
				{
				case 1:
				case 2:
					_stage++;
					break;
				case 3:
					_stage = 0;
					((Behaviour)_col2d).enabled = true;
					((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(_evil);
					break;
				}
				_frame %= Normal[_stage].Length;
			}
		}

		public HitResponse Hit(HitInstance damageInstance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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)
			if (((HitInstance)(ref damageInstance)).IsNailDamage && damageInstance.IsHeroDamage && !((Object)damageInstance.Source).name.Contains("Harpoon"))
			{
				DoBounce(damageInstance.Direction);
			}
			return HitResponse.op_Implicit((Response)0);
		}

		private void OnTriggerStay2D(Collider2D other)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!_evil && Object.op_Implicit((Object)(object)((Component)other).GetComponent<HeroController>()))
			{
				DoBounce(Mathf.RoundToMultipleOf(Mathf.Atan2(((Component)this).transform.position.y - ((Component)other).transform.position.y, ((Component)this).transform.position.x - ((Component)other).transform.position.x) * 57.29578f, 90f));
			}
		}

		private void DoBounce(float direction)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			PlaySound(_evil ? _hitEvil : _hitNormal, pitch: Random.Range(0.8f, 1f) - (_evil ? 0.2f : 0f), volume: _evil ? 25 : 5);
			((Behaviour)_col2d).enabled = false;
			((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(false);
			_frame = 0f;
			_stage = 1;
			HeroController instance = HeroController.instance;
			instance.DoSprintSkid();
			instance.FinishDownspike();
			instance.harpoonDashFSM.SendEvent("BOUNCE CANCEL");
			instance.doubleJumped = false;
			instance.airDashed = false;
			Vector3 val = Quaternion.Euler(0f, 0f, direction) * Vector2.op_Implicit(new Vector2(-20f, 0f)) * (_evil ? 0.36f : 1f) + new Vector3(0f, 10f, 0f);
			Wind.ActuallyJumping = false;
			instance.rb2d.linearVelocityY = val.y;
			val.x *= (_evil ? 1f : 1.75f);
			instance.rb2d.linearVelocityX = val.x;
			instance.AddExtraAirMoveVelocity(new DecayingVelocity
			{
				Velocity = new Vector2(val.x, 0f),
				Decay = 3f
			});
		}
	}
	public interface IPlayable
	{
		void Play();

		void Pause();

		void Reset();
	}
	public class PngObject : PreviewableBehaviour, IPlayable
	{
		private SpriteRenderer _renderer;

		protected Sprite[] Sprites;

		private float _remainingFrameTime;

		public int frame;

		public string url;

		public bool point;

		public bool ignoreGlow;

		public bool glow = true;

		public float ppu = 100f;

		private int _count = 1;

		public int vcount = 1;

		public int hcount = 1;

		public int dummy;

		public float frameTime = 1f;

		public bool playing;

		public bool loop = true;

		private void Awake()
		{
			if (!string.IsNullOrEmpty(url))
			{
				_renderer = ((Component)this).GetComponent<SpriteRenderer>();
				if (ignoreGlow)
				{
					glow = true;
				}
				if (!glow && Object.op_Implicit((Object)(object)_renderer))
				{
					((Renderer)_renderer).material = MiscFixers.SpriteMaterial;
				}
				CustomAssetManager.DoLoadSprite(url, point, ppu, hcount, vcount, SaveSprites);
				_count = Mathf.Max(1, hcount * vcount - dummy);
				Animator component = ((Component)this).GetComponent<Animator>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((Behaviour)component).enabled = false;
				}
			}
		}

		public void SaveSprites(Sprite[] newSprites)
		{
			Sprites = newSprites;
			if (Object.op_Implicit((Object)(object)_renderer))
			{
				_renderer.sprite = Sprites[0];
			}
			_remainingFrameTime = frameTime;
		}

		private void Update()
		{
			if (frameTime <= 0f || _count <= 1 || !playing || !Object.op_Implicit((Object)(object)_renderer) || Sprites == null)
			{
				return;
			}
			_remainingFrameTime -= Time.deltaTime;
			while (_remainingFrameTime < 0f && frameTime > 0f)
			{
				_remainingFrameTime += frameTime;
				frame++;
				((Component)this).gameObject.BroadcastEvent("OnFrameChange");
				if (frame >= _count)
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
					frame %= _count;
					if (!loop)
					{
						playing = false;
						break;
					}
				}
				_renderer.sprite = Sprites[frame];
			}
		}

		public void Play()
		{
			playing = true;
			if (Object.op_Implicit((Object)(object)_renderer) && Sprites != null)
			{
				_renderer.sprite = Sprites[frame];
			}
		}

		public void Pause()
		{
			playing = false;
		}

		public void Reset()
		{
			frame = 0;
			if (Object.op_Implicit((Object)(object)_renderer))
			{
				_renderer.sprite = Sprites[0];
			}
		}

		public void SetFrame(int newFrame)
		{
			frame = newFrame;
			if (frame >= _count)
			{
				((Component)this).gameObject.BroadcastEvent("OnFinish");
				frame %= _count;
				if (!loop)
				{
					playing = false;
					return;
				}
			}
			_renderer.sprite = Sprites[frame];
		}
	}
	public class ParticleObject : PngObject
	{
		private void Start()
		{
			ParticleSystemRenderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<ParticleSystemRenderer>(true);
			foreach (ParticleSystemRenderer val in componentsInChildren)
			{
				if (Extensions.IsNullOrEmpty<Sprite>((ICollection<Sprite>)Sprites) || !Object.op_Implicit((Object)(object)((Renderer)val).material))
				{
					break;
				}
				((Renderer)val).material.mainTexture = (Texture)(object)Sprites[0].texture;
			}
		}
	}
	public class UIPngObject : PngObject
	{
		public float xOffset;

		public float yOffset;

		public int anchorTo;

		private static readonly int UILayer = LayerMask.NameToLayer("UI");

		private PositionConstraint _constraint;

		private SpriteRenderer _sr;

		private GameObject _par;

		private static readonly List<UIPngObject> Pngs = new List<UIPngObject>();

		public bool ignoreHudOut;

		private static bool _hudOut;

		private bool _previewing;

		public static void Init()
		{
			typeof(GameCameras).Hook("HUDIn", (Action<Action<GameCameras>, GameCameras>)delegate(Action<GameCameras> orig, GameCameras self)
			{
				_hudOut = false;
				Pngs.RemoveAll((UIPngObject png) => !Object.op_Implicit((Object)(object)png));
				foreach (UIPngObject item in Pngs.Where((UIPngObject png) => Object.op_Implicit((Object)(object)png._constraint) && png.ignoreHudOut))
				{
					item._constraint.constraintActive = true;
				}
				orig(self);
			});
			typeof(GameCameras).Hook("HUDOut", (Action<Action<GameCameras>, GameCameras>)delegate(Action<GameCameras> orig, GameCameras self)
			{
				_hudOut = true;
				Pngs.RemoveAll((UIPngObject png) => !Object.op_Implicit((Object)(object)png));
				foreach (UIPngObject item2 in Pngs.Where((UIPngObject png) => Object.op_Implicit((Object)(object)png._constraint) && png.ignoreHudOut))
				{
					item2._constraint.constraintActive = false;
				}
				orig(self);
			});
		}

		public void Start()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).gameObject.layer = UILayer;
			Transform sourceTransform = ((Component)GameCameras.instance.hudCamera).transform.Find("In-game").Find("Anchor TL").Find("Hud Canvas Offset")
				.Find("Hud Canvas");
			if (isAPreview && Object.op_Implicit((Object)(object)((Component)this).transform.parent))
			{
				_par = ((Component)((Component)this).transform.parent).gameObject;
				((Component)this).transform.parent = null;
			}
			_constraint = ((Component)this).gameObject.AddComponent<PositionConstraint>();
			Pngs.Add(this);
			_constraint.constraintActive = true;
			ConstraintSource val = default(ConstraintSource);
			((ConstraintSource)(ref val)).sourceTransform = sourceTransform;
			((ConstraintSource)(ref val)).weight = 1f;
			ConstraintSource val2 = val;
			_constraint.AddSource(val2);
			_sr = ((Component)this).GetComponent<SpriteRenderer>();
			((Renderer)_sr).sortingLayerName = "Over";
			UpdatePos();
			if (_hudOut && Object.op_Implicit((Object)(object)_constraint))
			{
				_constraint.constraintActive = false;
				((Component)this).transform.position = new Vector3(-10.3535f, 7.533f, 38.1f) + _constraint.translationOffset;
			}
		}

		private void OnEnable()
		{
			Extensions.AddIfNotPresent<UIPngObject>(Pngs, this);
			if (_hudOut && Object.op_Implicit((Object)(object)_constraint))
			{
				_constraint.constraintActive = false;
			}
		}

		private void UpdatePos()
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(xOffset + 10.3535f, yOffset - 6.81f);
			switch (anchorTo)
			{
			case 1:
				val.x += 0.94f * (float)PlayerData.instance.maxHealth;
				break;
			case 2:
			{
				if (!Object.op_Implicit((Object)(object)ManagerSingleton<ToolItemManager>.Instance) || ManagerSingleton<ToolItemManager>.Instance.boundAttackTools == null)
				{
					return;
				}
				Transform val2 = ((Component)GameCameras.instance.hudCamera).transform.Find("In-game").Find("Anchor TL").Find("Hud Canvas Offset")
					.Find("Hud Canvas");
				Transform val3 = val2.Find("Tool Icons");
				val.x += 1.02f * (float)ManagerSingleton<ToolItemManager>.Instance.boundAttackTools.Count((ToolItem o) => Object.op_Implicit((Object)(object)o)) + Extensions.GetPositionX(((Component)val3).transform);
				break;
			}
			}
			_constraint.translationOffset = Vector2.op_Implicit(val);
		}

		private void LateUpdate()
		{
			if (anchorTo != 0)
			{
				UpdatePos();
			}
			if (isAPreview)
			{
				if (!Object.op_Implicit((Object)(object)_par))
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
				else if (_previewing != Settings.Preview.IsPressed)
				{
					_previewing = !_previewing;
					((Renderer)_sr).enabled = _previewing;
				}
			}
		}
	}
	public class Mp4Object : MonoBehaviour, IPlayable
	{
		public string url;

		public bool playOnStart = true;

		public bool glow;

		private VideoPlayer _player;

		private bool _shouldPlay = true;

		private bool _playing = true;

		private bool _started;

		private void Awake()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			if (!string.IsNullOrEmpty(url))
			{
				if (!glow)
				{
					((Renderer)((Component)this).GetComponent<SpriteRenderer>()).material = MiscFixers.SpriteMaterial;
				}
				_player = ((Component)this).gameObject.GetComponent<VideoPlayer>();
				_player.loopPointReached += (EventHandler)delegate
				{
					((Component)this).gameObject.BroadcastEvent("OnFinish");
				};
				CustomAssetManager.DoLoadVideo(_player, Extensions.GetScaleX(((Component)this).transform), url);
			}
		}

		private void Update()
		{
			if (!_started)
			{
				_started = true;
				if (!playOnStart)
				{
					Pause();
				}
			}
			bool isPaused = GameManager.instance.isPaused;
			if (!_shouldPlay)
			{
				return;
			}
			if (isPaused)
			{
				if (_playing)
				{
					_playing = false;
					_player.Pause();
				}
			}
			else if (!_playing)
			{
				_playing = true;
				_player.Play();
			}
		}

		public void Play()
		{
			_player.Play();
			_shouldPlay = true;
			_playing = true;
		}

		public void Pause()
		{
			_player.Pause();
			_shouldPlay = false;
			_playing = false;
		}

		public void Reset()
		{
			_player.time = 0.0;
		}
	}
	public class WavObject : SoundMaker, IPlayable
	{
		[CompilerGenerated]
		private sealed class <PlayWhenReady>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public WavObject <>4__this;

			private float <v>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => !Object.op_Implicit((Object)(object)<>4__this) || Object.op_Implicit((Object)(object)<>4__this.sound)));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)<>4__this))
					{
						return false;
					}
					<>4__this._playing = true;
					if (<>4__this._started && <>4__this.Source.time < <>4__this.sound.length)
					{
						<>4__this.Source.PlayScheduled(AudioSettings.dspTime);
						return false;
					}
					<>4__this._started = true;
					<>4__this.PlaySound(<>4__this.sound, <>4__this.Volume, <>4__this.pitch, <>4__this.globalSound, <>4__this.loop, setVol: false);
					if (!Utility.IsNullOrWhiteSpace(<>4__this.syncId) && Syncs.TryGetValue(<>4__this.syncId, out <v>5__1))
					{
						<>4__this.Source.time = <v>5__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();
			}
		}

		public string url;

		public AudioClip sound;

		public int soundType;

		private float _gmVol = 1f;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private float <Volume>k__BackingField = 1f;

		public float pitch = 1f;

		public bool globalSound = true;

		public bool loop;

		private bool _started;

		private bool _playing;

		public string syncId;

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

		private float GmVol
		{
			get
			{
				int num = soundType;
				if (1 == 0)
				{
				}
				float num2 = num switch
				{
					2 => GameManager.instance.gameSettings.soundVolume, 
					1 => GameManager.instance.gameSettings.musicVolume, 
					_ => GameManager.instance.gameSettings.masterVolume, 
				};
				if (1 == 0)
				{
				}
				return num2 / 10f;
			}
		}

		public float Volume
		{
			[CompilerGenerated]
			get
			{
				return <Volume>k__BackingField;
			}
			set
			{
				_gmVol = GmVol;
				Source.volume = value * _gmVol;
				<Volume>k__BackingField = value;
			}
		}

		protected void Start()
		{
			if (!string.IsNullOrEmpty(url))
			{
				CustomAssetManager.DoLoadSound(url, delegate(AudioClip clip)
				{
					sound = clip;
					sound.LoadAudioData();
				});
			}
		}

		public void Play()
		{
			((MonoBehaviour)this).StartCoroutine(PlayWhenReady());
		}

		[IteratorStateMachine(typeof(<PlayWhenReady>d__19))]
		private IEnumerator PlayWhenReady()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayWhenReady>d__19(0)
			{
				<>4__this = this
			};
		}

		public void Pause()
		{
			_playing = false;
			Source.Pause();
		}

		public void Reset()
		{
			_started = false;
			bool playing = _playing;
			Source.Stop();
			if (!Utility.IsNullOrWhiteSpace(syncId))
			{
				Syncs.Remove(syncId);
			}
			if (playing)
			{
				Play();
			}
		}

		private void Update()
		{
			if (!Mathf.Approximately(_gmVol, GmVol))
			{
				Volume = Volume;
			}
			if (!Utility.IsNullOrWhiteSpace(syncId) && _started)
			{
				Syncs[syncId] = Source.time;
			}
		}
	}
	public class PngPreview : MonoBehaviour
	{
		public float ppu = 100f;

		public bool point;

		public int vcount = 1;

		public int hcount = 1;
	}
	public class CustomDamager : MonoBehaviour
	{
		public int damageAmount = 1;

		public DamagePropertyFlags flags = (DamagePropertyFlags)0;

		private void OnTriggerEnter2D(Collider2D other)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			HeroController component = ((Component)other).gameObject.GetComponent<HeroController>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.TakeDamage(((Component)this).gameObject, (CollisionSide)4, damageAmount, (HazardType)2, flags);
			}
		}
	}
	public class Darkness : MonoBehaviour
	{
		private static readonly List<Darkness> DarknessObjects = new List<Darkness>();

		public int amount = 1;

		private void OnEnable()
		{
			DarknessObjects.Add(this);
			Refresh();
		}

		private void OnDisable()
		{
			DarknessObjects.Remove(this);
			Refresh();
		}

		private void Update()
		{
			if (DarknessObjects.Count > 0)
			{
				Refresh();
			}
		}

		private static void Refresh()
		{
			DarknessRegion.SetDarknessLevel(Math.Clamp(DarknessObjects.Sum((Darkness o) => o.amount), 0, 2));
		}
	}
	public class DreamBlock : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass23_0
		{
			public bool blockDir;

			internal void <Init>b__8(Action<HeroController, bool> orig, HeroController self, bool startAlreadyDashing)
			{
				<>c__DisplayClass23_1 CS$<>8__locals0 = new <>c__DisplayClass23_1
				{
					CS$<>8__locals1 = this,
					self = self,
					orig = orig,
					startAlreadyDashing = startAlreadyDashing
				};
				if (TouchingBlocks.Count > 0 && CS$<>8__locals0.self.cState.wallSliding)
				{
					HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
					((MonoBehaviour)CS$<>8__locals0.self).StartCoroutine(DashLater(CS$<>8__locals0.self.touchingWallR && !((OneAxisInputControl)inputActions.Left).IsPressed, CS$<>8__locals0.self.touchingWallL && !((OneAxisInputControl)inputActions.Right).IsPressed));
				}
				else
				{
					CS$<>8__locals0.orig(CS$<>8__locals0.self, CS$<>8__locals0.startAlreadyDashing);
					blockDir = false;
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass23_1.<<Init>g__DashLater|13>d))]
				IEnumerator DashLater(bool willRight, bool willLeft)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass23_1.<<Init>g__DashLater|13>d(0)
					{
						<>4__this = CS$<>8__locals0,
						willRight = willRight,
						willLeft = willLeft
					};
				}
			}

			internal void <Init>b__10(Action<HeroController> orig, HeroController self)
			{
				if (!blockDir)
				{
					orig(self);
				}
			}

			internal void <Init>b__11(Action<HeroController> orig, HeroController self)
			{
				if (!blockDir)
				{
					orig(self);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass23_1
		{
			public HeroController self;

			public Action<HeroController, bool> orig;

			public bool startAlreadyDashing;

			public <>c__DisplayClass23_0 CS$<>8__locals1;
		}

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

			private object <>2__current;

			private bool <paused>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					_source.volume = GameManager.instance.GetImplicitCinematicVolume() / 5f;
					_source.loop = false;
					_source.clip = _enter;
					_source.Play();
					<paused>5__1 = false;
					goto IL_0145;
				case 1:
					<>1__state = -1;
					goto IL_00e6;
				case 2:
					{
						<>1__state = -1;
						goto IL_0145;
					}
					IL_0145:
					if (ActiveBlocks.Count > 0)
					{
						if (GameManager.instance.isPaused)
						{
							if (!<paused>5__1)
							{
								_source.Pause();
							}
							<paused>5__1 = true;
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
						if (<paused>5__1)
						{
							<paused>5__1 = false;
							_source.Play();
						}
						goto IL_00e6;
					}
					return false;
					IL_00e6:
					if (!_source.isPlaying && !<paused>5__1)
					{
						_source.loop = true;
						_source.clip = _loop;
						_source.Play();
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

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

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

		private const string DREAM_BLOCK_SOURCE = "DreamBlock";

		private static readonly List<DreamBlock> ActiveBlocks = new List<DreamBlock>();

		private static readonly List<DreamBlock> TouchingBlocks = new List<DreamBlock>();

		private static bool _damaging;

		private static int _wallJumpBuffer;

		private static int _turnaroundBuffer;

		private static bool _extendedJump;

		private static AudioSource _source;

		private static AudioClip _enter;

		private static AudioClip _loop;

		private static AudioClip _exit;

		private BoxCollider2D _collider;

		private EmissionModule _emission;

		private bool _setup;

		private ShapeModule _shape;

		private BoxCollider2D _trigger;

		private void Awake()
		{
			_collider = ((Component)this).GetComponents<BoxCollider2D>().First((BoxCollider2D obj) => !((Collider2D)obj).isTrigger);
			_trigger = ((Component)this).GetComponents<BoxCollider2D>().First((BoxCollider2D obj) => ((Collider2D)obj).isTrigger);
		}

		private void Start()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Transform val = HeroController.instance.transform.Find("Sounds");
			Transform obj = val.Find("DreamBlock");
			_source = ((obj != null) ? ((Component)obj).GetComponent<AudioSource>() : null);
			if (!Object.op_Implicit((Object)(object)_source))
			{
				GameObject val2 = new GameObject("DreamBlock");
				val2.transform.parent = val;
				_source = val2.AddComponent<AudioSource>();
			}
		}

		private void Update()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			Physics2D.IgnoreCollision(HeroController.instance.col2d, (Collider2D)(object)_collider, ((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Dash).IsPressed);
			if (!_setup)
			{
				_setup = true;
				ref EmissionModule emission = ref _emission;
				((EmissionModule)(ref emission)).rateOverTimeMultiplier = ((EmissionModule)(ref emission)).rateOverTimeMultiplier * (((Component)this).transform.localScale.x * ((Component)this).transform.localScale.y);
				((ShapeModule)(ref _shape)).scale = new Vector3(10f - 3f / ((Component)this).transform.localScale.x, 10f - 3f / ((Component)this).transform.localScale.y, 10f / ((Component)this).transform.localScale.z);
				_trigger.size = new Vector2(_collider.size.x - 0.2f / ((Component)this).transform.localScale.x, _collider.size.y - 0.2f / ((Component)this).transform.localScale.y);
			}
		}

		private void OnCollisionEnter2D(Collision2D other)
		{
			if (other.gameObject.layer == 9)
			{
				TouchingBlocks.Add(this);
			}
		}

		private void OnCollisionExit2D(Collision2D other)
		{
			if (other.gameObject.layer == 9)
			{
				TouchingBlocks.Remove(this);
			}
		}

		private void OnTriggerExit2D(Collider2D other)
		{
			if (((Component)other).gameObject.layer == 9 && ActiveBlocks.Contains(this))
			{
				ActiveBlocks.Remove(this);
				if (ActiveBlocks.Count == 0)
				{
					MoveOut();
				}
				if (!HeroController.instance.dashingDown)
				{
					_wallJumpBuffer = 2;
				}
			}
		}

		private void OnTriggerStay2D(Collider2D other)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)other).gameObject.layer != 9 || ActiveBlocks.Contains(this))
			{
				return;
			}
			Bounds bounds = ((Collider2D)_trigger).bounds;
			Bounds bounds2 = other.bounds;
			float x = ((Bounds)(ref bounds2)).center.x;
			bounds2 = other.bounds;
			if (((Bounds)(ref bounds)).Contains(new Vector3(x, ((Bounds)(ref bounds2)).center.y, 0.01f)))
			{
				HeroController instance = HeroController.instance;
				((Renderer)instance.renderer).enabled = false;
				if (!instance.dashingDown)
				{
					Rigidbody2D rb2d = instance.rb2d;
					rb2d.constraints = (RigidbodyConstraints2D)(rb2d.constraints | 2);
				}
				ActiveBlocks.Add(this);
				if (ActiveBlocks.Count == 1)
				{
					((MonoBehaviour)this).StartCoroutine(Play());
				}
			}
		}

		public static void Init()
		{
			ResourceUtils.LoadClipResource("Dream.dream_block_enter", delegate(AudioClip clip)
			{
				_enter = clip;
			});
			ResourceUtils.LoadClipResource("Dream.dream_block_loop", delegate(AudioClip clip)
			{
				_loop = clip;
			});
			ResourceUtils.LoadClipResource("Dream.dream_block_exit", delegate(AudioClip clip)
			{
				_exit = clip;
			});
			typeof(HeroController).Hook("SceneInit", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				orig(self);
				ActiveBlocks.Clear();
				TouchingBlocks.Clear();
			});
			HookUtils.OnHeroUpdate = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroUpdate, (Action<HeroController>)delegate(HeroController self)
			{
				if (_wallJumpBuffer > 0)
				{
					_wallJumpBuffer--;
				}
				if (_turnaroundBuffer > 0)
				{
					_turnaroundBuffer--;
				}
				if (ActiveBlocks.Count > 0)
				{
					self.cState.dashing = true;
					self.dash_timer = (self.dashingDown ? self.DOWN_DASH_TIME : self.DASH_TIME);
				}
				if (_extendedJump)
				{
					self.JUMP_STEPS = 16;
					self.WJ_KICKOFF_SPEED = 40f;
				}
				else
				{
					self.JUMP_STEPS = 8;
					self.WJ_KICKOFF_SPEED = 25f;
				}
				if (((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Jump).WasPressed && !self.dashingDown)
				{
					_turnaroundBuffer = 3;
				}
			});
			typeof(HeroController).Hook("CanWallJump", (Func<Func<HeroController, bool, bool>, HeroController, bool, bool>)delegate(Func<HeroController, bool, bool> orig, HeroController self, bool mustBeNearWall)
			{
				_extendedJump = false;
				if (orig(self, mustBeNearWall))
				{
					return true;
				}
				if (_wallJumpBuffer <= 0)
				{
					return false;
				}
				if (self.cState.facingRight)
				{
					self.touchingWallL = true;
				}
				else
				{
					self.touchingWallR = true;
				}
				if (self.playerData.hasWalljump && !self.cState.touchingNonSlider)
				{
					_extendedJump = true;
					return true;
				}
				return false;
			});
			typeof(HeroController).Hook("DoWallJump", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				_wallJumpBuffer = 0;
				orig(self);
			});
			typeof(HeroController).Hook("TakeDamage", (Action<Action<HeroController, GameObject, CollisionSide, int, HazardType, DamagePropertyFlags>, HeroController, GameObject, CollisionSide, int, HazardType, DamagePropertyFlags>)delegate(Action<HeroController, GameObject, CollisionSide, int, HazardType, DamagePropertyFlags> orig, HeroController self, GameObject go, CollisionSide side, int amount, HazardType type, DamagePropertyFlags damagePropertyFlags)
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (ActiveBlocks.Count > 0)
				{
					_damaging = true;
					ActiveBlocks.Clear();
					MoveOut();
				}
				orig(self, go, side, amount, type, damagePropertyFlags);
			});
			bool blockDir = false;
			<>c__DisplayClass23_0 CS$<>8__locals0;
			typeof(HeroController).Hook("HeroDash", (Action<Action<HeroController, bool>, HeroController, bool>)delegate(Action<HeroController, bool> orig, HeroController self, bool startAlreadyDashing)
			{
				<>c__DisplayClass23_1 CS$<>8__locals1 = new <>c__DisplayClass23_1();
				CS$<>8__locals1.CS$<>8__locals1 = CS$<>8__locals0;
				CS$<>8__locals1.self = self;
				CS$<>8__locals1.orig = orig;
				CS$<>8__locals1.startAlreadyDashing = startAlreadyDashing;
				if (TouchingBlocks.Count > 0 && CS$<>8__locals1.self.cState.wallSliding)
				{
					HeroActions inputActions = ManagerSingleton<InputHandler>.Instance.inputActions;
					((MonoBehaviour)CS$<>8__locals1.self).StartCoroutine(DashLater(CS$<>8__locals1.self.touchingWallR && !((OneAxisInputControl)inputActions.Left).IsPressed, CS$<>8__locals1.self.touchingWallL && !((OneAxisInputControl)inputActions.Right).IsPressed));
				}
				else
				{
					CS$<>8__locals1.orig(CS$<>8__locals1.self, CS$<>8__locals1.startAlreadyDashing);
					blockDir = false;
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass23_1.<<Init>g__DashLater|13>d))]
				IEnumerator DashLater(bool willRight, bool willLeft)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass23_1.<<Init>g__DashLater|13>d(0)
					{
						<>4__this = CS$<>8__locals1,
						willRight = willRight,
						willLeft = willLeft
					};
				}
			});
			typeof(HeroController).Hook("CanWallScramble", (Func<Func<HeroController, bool>, HeroController, bool>)((Func<HeroController, bool> orig, HeroController self) => orig(self) && TouchingBlocks.Count == 0));
			typeof(HeroController).Hook("FaceLeft", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				if (!blockDir)
				{
					orig(self);
				}
			});
			typeof(HeroController).Hook("FaceRight", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				if (!blockDir)
				{
					orig(self);
				}
			});
			typeof(HeroController).Hook("OnCollisionEnter2D", (Action<Action<HeroController, Collision2D>, HeroController, Collision2D>)delegate(Action<HeroController, Collision2D> orig, HeroController self, Collision2D collision)
			{
				if (ActiveBlocks.Count > 0 && !Object.op_Implicit((Object)(object)collision.gameObject.GetComponent<DreamBlock>()))
				{
					if (self.playerData.hasWalljump && (_turnaroundBuffer > 0 || ((OneAxisInputControl)ManagerSingleton<InputHandler>.Instance.inputActions.Jump).WasPressed))
					{
						self.touchingWallR = !self.cState.facingRight;
						self.touchingWallL = self.cState.facingRight;
						self.cState.touchingWall = true;
						self.cState.wallSliding = true;
						self.cState.wallJumping = false;
						self.DoWallJump();
						if (self.cState.facingRight)
						{
							self.FaceLeft();
						}
						else
						{
							self.FaceRight();
						}
					}
					else
					{
						self.TakeDamage(collision.gameObject, (CollisionSide)4, 1, (HazardType)2, (DamagePropertyFlags)0);
					}
				}
				orig(self, collision);
			});
		}

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

		private static void MoveOut()
		{
			//IL_0027: 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)
			HeroController instance = HeroController.instance;
			if (!_damaging)
			{
				((Renderer)instance.renderer).enabled = true;
			}
			Rigidbody2D rb2d = instance.rb2d;
			rb2d.constraints = (RigidbodyConstraints2D)(rb2d.constraints & -3);
			instance.rb2d.gravityScale = 1f;
			_damaging = false;
			instance.ResetAirMoves();
			_source.Stop();
			_source.PlayOneShot(_exit);
			instance.dash_timer = 0f;
		}

		public void SetupParticles()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem val = ((Component)this).gameObject.AddComponent<ParticleSystem>();
			MainModule main = val.main;
			((MainModule)(ref main)).startLifetimeMultiplier = ((MainModule)(ref main)).startLifetimeMultiplier / 2f;
			((MainModule)(ref main)).startSpeedMultiplier = 0f;
			MinMaxGradient val2 = default(MinMaxGradient);
			((MinMaxGradient)(ref val2)).mode = (ParticleSystemGradientMode)4;
			Gradient val3 = new Gradient();
			val3.colorKeys = (GradientColorKey[])(object)new GradientColorKey[4]
			{
				new GradientColorKey(new Color(1f, 0f, 0f), 0f),
				new GradientColorKey(new Color(0f, 1f, 0f), 0.33f),
				new GradientColorKey(new Color(0f, 0f, 1f), 0.66f),
				new GradientColorKey(new Color(1f, 1f, 0f), 1f)
			};
			((MinMaxGradient)(ref val2)).gradient = val3;
			MinMaxGradient startColor = val2;
			((MainModule)(ref main)).startColor = startColor;
			((MainModule)(ref main)).scalingMode = (ParticleSystemScalingMode)2;
			ColorOverLifetimeModule colorOverLifetime = val.colorOverLifetime;
			((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
			val3 = new Gradient();
			val3.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[3]
			{
				new GradientAlphaKey(0f, 0f),
				new GradientAlphaKey(1f, 0.5f),
				new GradientAlphaKey(0f, 1f)
			};
			((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(val3);
			ParticleSystemRenderer component = ((Component)val).GetComponent<ParticleSystemRenderer>();
			((Renderer)component).material = new Material(Shader.Find("Sprites/Default"))
			{
				mainTexture = (Texture)(object)ResourceUtils.LoadSpriteResource("Dream.star", (FilterMode)0).texture
			};
			((Renderer)component).sortingOrder = 1;
			_shape = val.shape;
			((ShapeModule)(ref _shape)).shapeType = (ParticleSystemShapeType)5;
			SizeOverLifetimeModule sizeOverLifetime = val.sizeOverLifetime;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = new MinMaxCurve(0.4f, 0.6f);
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).sizeMultiplier = 0.1f;
			_emission = val.emission;
		}
	}
	public class FakePerformanceRegion : HeroPerformanceRegion
	{
		private static readonly List<FakePerformanceRegion> Regions = new List<FakePerformanceRegion>();

		public float rangeMult = 1f;

		public static void Init()
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			typeof(HeroPerformanceRegion).Hook("IsInRange", (Func<Func<Vector2, Vector2, Vector2, bool>, Vector2, Vector2, Vector2, bool>)((Func<Vector2, Vector2, Vector2, bool> orig, Vector2 pos, Vector2 centre, Vector2 size) => Regions.Aggregate(orig(pos, centre, size) && HeroPerformanceRegion._instance.isPerforming, delegate(bool current, FakePerformanceRegion r)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val4 = size;
				if (((ToolBase)Gameplay.MusicianCharmTool).IsEquipped)
				{
					val4 /= Gameplay.MusicianCharmNeedolinRangeMult;
				}
				val4 *= r.rangeMult;
				return current || orig(pos, Vector2.op_Implicit(((Component)r).transform.position), val4);
			})));
			typeof(HeroPerformanceRegion).Hook("IsPlayingInRange", (Func<Func<Vector2, float, bool>, Vector2, float, bool>)((Func<Vector2, float, bool> orig, Vector2 pos, float radius) => Regions.Aggregate(orig(pos, radius) && HeroPerformanceRegion._instance.isPerforming, (bool current, FakePerformanceRegion r) => current || ((HeroPerformanceRegion)r).InternalIsInRange(pos, radius * r.rangeMult))));
			typeof(HeroPerformanceRegion).Hook("InternalGetAffectedRangeWithRadius", (Func<Func<HeroPerformanceRegion, Transform, float, AffectedState>, HeroPerformanceRegion, Transform, float, AffectedState>)delegate(Func<HeroPerformanceRegion, Transform, float, AffectedState> orig, HeroPerformanceRegion self, Transform otherTransform, float radius)
			{
				//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_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Expected I4, but got Unknown
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Invalid comparison between Unknown and I4
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)self != (Object)(object)HeroPerformanceRegion._instance)
				{
					return orig(self, otherTransform, radius);
				}
				AffectedState val = orig(self, otherTransform, radius);
				foreach (AffectedState item in Regions.Select((FakePerformanceRegion r) => orig((HeroPerformanceRegion)(object)r, otherTransform, radius * r.rangeMult)))
				{
					AffectedState val2 = val;
					AffectedState val3 = val2;
					switch ((int)val3)
					{
					case 0:
						if ((int)item == 0)
						{
							continue;
						}
						break;
					case 1:
						if ((int)item != 2)
						{
							continue;
						}
						break;
					default:
						continue;
					}
					val = item;
				}
				return val;
			});
			new Hook((MethodBase)typeof(HeroPerformanceRegion).GetProperty("IsPerforming", BindingFlags.Static | BindingFlags.Public).GetGetMethod(), (Delegate)(Func<Func<bool>, bool>)((Func<bool> orig) => orig() || Regions.Count > 0));
		}

		public void Awake()
		{
		}

		private void OnEnable()
		{
			Regions.Add(this);
		}

		private void OnDisable()
		{
			Regions.Remove(this);
		}
	}
	public class Fallthrough : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ReEnableCollision>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Collider2D self;

			public Collider2D other;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				ColliderDistance2D val = self.Distance(other);
				if (((ColliderDistance2D)(ref val)).isOverlapped)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				Physics2D.IgnoreCollision(self, other, false);
				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 float fallthroughTime;

		private float _time;

		private void OnCollisionExit2D(Collision2D collision)
		{
			if (Object.op_Implicit((Object)(object)collision.gameObject.GetComponent<HeroController>()))
			{
				_time = 0f;
			}
		}

		private void OnCollisionStay2D(Collision2D collision)
		{
			if (!Object.op_Implicit((Object)(object)collision.gameObject.GetComponent<HeroController>()))
			{
				return;
			}
			if (!OneAxisInputControl.op_Implicit((OneAxisInputControl)(object)ManagerSingleton<InputHandler>.Instance.inputActions.Down))
			{
				_time = 0f;
				return;
			}
			_time += Time.deltaTime;
			if (!(_time < fallthroughTime))
			{
				_time = 0f;
				Physics2D.IgnoreCollision(collision.collider, collision.otherCollider);
				((MonoBehaviour)this).StartCoroutine(ReEnableCollision(collision.collider, collision.otherCollider));
			}
		}

		[IteratorStateMachine(typeof(<ReEnableCollision>d__4))]
		private static IEnumerator ReEnableCollision(Collider2D self, Collider2D other)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReEnableCollision>d__4(0)
			{
				self = self,
				other = other
			};
		}
	}
	public class FloatAnim : MonoBehaviour
	{
		public bool active = true;

		private float _startY;

		private void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			_startY = ((Component)this).transform.localPosition.y;
		}

		private void Update()
		{
			Extensions.SetLocalPositionY(((Component)this).transform, _startY + (active ? (Mathf.Sin(Time.time * 4f) / 15f) : 0f));
		}
	}
	public class FrostMarker : MonoBehaviour
	{
		internal static readonly List<FrostMarker> ActiveFrost = new List<FrostMarker>();

		public float frostSpeed;

		public static void Init()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			new Hook((MethodBase)typeof(CustomSceneManager).GetProperty("FrostSpeed").GetGetMethod(), (Delegate)(Func<Func<CustomSceneManager, float>, CustomSceneManager, float>)((Func<CustomSceneManager, float> orig, CustomSceneManager self) => orig(self) + ActiveFrost.Sum((FrostMarker frost) => frost.frostSpeed) - (float)(EditManager.IsEditing ? 9999 : 0)));
		}

		private void OnEnable()
		{
			ActiveFrost.Add(this);
		}

		private void OnDisable()
		{
			ActiveFrost.Remove(this);
		}
	}
	public class JellyEgg : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <OnTriggerStay2D>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Collider2D other;

			public JellyEgg <>4__this;

			private GameObject <expl>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)<>4__this._col) || !Object.op_Implicit((Object)(object)<>4__this._renderer))
					{
						return false;
					}
					if (!Object.op_Implicit((Object)(object)((Component)other).GetComponentInParent<HeroController>()))
					{
						return false;
					}
					<expl>5__1 = Object.Instantiate<GameObject>(<>4__this.explosion);
					<expl>5__1.transform.position = ((Component)<>4__this).transform.position;
					<expl>5__1.SetActive(true);
					((Behaviour)<>4__this._col).enabled = false;
					((Renderer)<>4__this._renderer).enabled = false;
					if (<>4__this.regenTime >= 0f)
					{
						<>2__current = (object)new WaitForSeconds(<>4__this.regenTime);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					((Behaviour)<>4__this._col).enabled = true;
					((Renderer)<>4__this._renderer).enabled = true;
					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 GameObject explosion;

		public float regenTime = -1f;

		private SpriteRenderer _renderer;

		private Collider2D _col;

		private void Start()
		{
			_renderer = ((Component)this).GetComponent<SpriteRenderer>();
			_col = ((Component)this).GetComponent<Collider2D>();
			((Renderer)_renderer).material = MiscFixers.SpriteMaterial;
		}

		[IteratorStateMachine(typeof(<OnTriggerStay2D>d__5))]
		private IEnumerator OnTriggerStay2D(Collider2D other)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnTriggerStay2D>d__5(0)
			{
				<>4__this = this,
				other = other
			};
		}
	}
	public class LineObject : MonoBehaviour
	{
		private static readonly Dictionary<string, List<LineObject>> Objects = new Dictionary<string, List<LineObject>>();

		public string id;

		private bool _setup;

		public float r;

		public float g;

		public float b;

		public float a;

		public float width;

		public Color LineColour
		{
			set
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				r = value.r;
				g = value.g;
				b = value.b;
				a = value.a;
			}
		}

		private void OnEnable()
		{
			if (!Objects.ContainsKey(id))
			{
				Objects[id] = new List<LineObject>();
			}
			Objects[id].Add(this);
		}

		private void OnDisable()
		{
			if (Objects.TryGetValue(id, out var value))
			{
				value.Remove(this);
				if (Extensions.IsNullOrEmpty<LineObject>((ICollection<LineObject>)value))
				{
					Objects.Remove(id);
				}
			}
		}

		private void Setup()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			_setup = true;
			if (!Objects.TryGetValue(id, out var value))
			{
				return;
			}
			EdgeCollider2D component = ((Component)this).GetComponent<EdgeCollider2D>();
			Vector3[] array = value.Select(delegate(LineObject obj)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				obj._setup = true;
				return ((Component)obj).transform.position - ((Component)this).transform.position;
			}).ToArray();
			LineRenderer component2 = ((Component)this).GetComponent<LineRenderer>();
			Color val = default(Color);
			((Color)(ref val))..ctor(r, g, b, a);
			component2.endColor = val;
			component2.startColor = val;
			float startWidth = (component2.endWidth = width);
			component2.startWidth = startWidth;
			component2.useWorldSpace = false;
			component2.positionCount = array.Length;
			component2.SetPositions(array);
			component.points = value.Select(delegate(LineObject obj)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				obj._setup = true;
				if ((Object)(object)((Component)obj).gameObject != (Object)(object)((Component)this).gameObject)
				{
					((Component)obj).gameObject.RemoveComponent<EdgeCollider2D>();
				}
				return Vector2.op_Implicit(((Component)obj).transform.position - ((Component)this).transform.position);
			}).ToArray();
		}

		private void Update()
		{
			if (!_setup)
			{
				Setup();
			}
		}
	}
	public class Relay : MonoBehaviour
	{
		public bool canCall = true;

		public bool startActivated = true;

		public bool semiPersistent;

		[CanBeNull]
		public string id;

		public float relayChance = 1f;

		public float delay;

		public bool broadcastImmediately;

		private PersistentRelayItem _item;

		private float _schedule = -1f;

		private bool _shouldRelay;

		private void Awake()
		{
			_shouldRelay = startActivated;
			if (!string.IsNullOrEmpty(id))
			{
				_item = ((Component)this).gameObject.AddComponent<PersistentRelayItem>();
				_item.defaultValue = startActivated;
				((PersistentItem<bool>)(object)_item).OnSetSaveState += SetSaveState;
				((PersistentItem<bool>)(object)_item).OnGetSaveState += GetSaveState;
			}
		}

		private void OnDestroy()
		{
			if (!string.IsNullOrEmpty(id))
			{
				((PersistentItem<bool>)(object)_item).OnSetSaveState -= SetSaveState;
				((PersistentItem<bool>)(object)_item).OnGetSaveState -= GetSaveState;
			}
		}

		private void SetSaveState(bool value)
		{
			_shouldRelay = value;
			if (value && broadcastImmediately)
			{
				DoRelay();
			}
		}

		private void GetSaveState(out bool value)
		{
			value = _shouldRelay;
		}

		private void Start()
		{
			if (!string.IsNullOrEmpty(id))
			{
				((PersistentItem<bool>)(object)_item).ItemData.IsSemiPersistent = semiPersistent;
				((PersistentItem<bool>)(object)_item).ItemData.SceneName = "Universal";
				((PersistentItem<bool>)(object)_item).ItemData.ID = id;
			}
		}

		private void Update()
		{
			if (broadcastImmediately && string.IsNullOrEmpty(id))
			{
				DoRelay();
				broadcastImmediately = false;
			}
			canCall = true;
			if (_schedule > 0f)
			{
				_schedule -= Time.deltaTime;
				if (_schedule <= 0f)
				{
					EventManager.BroadcastEvent(((Component)this).gameObject, "OnCall");
				}
			}
		}

		public bool ShouldRelay()
		{
			if (Random.value > relayChance)
			{
				return false;
			}
			return canCall && _shouldRelay;
		}

		public void DoRelay()
		{
			if (ShouldRelay())
			{
				canCall = false;
				if (delay <= 0f)
				{
					EventManager.BroadcastEvent(((Component)this).gameObject, "OnCall");
				}
				else
				{
					_schedule = delay;
				}
			}
		}

		public void EnableRelay()
		{
			_shouldRelay = true;
		}

		public void DisableRelay()
		{
			_shouldRelay = false;
		}
	}
	public class PersistentRelayItem : PersistentBoolItem
	{
		public bool defaultValue;

		public override bool DefaultValue => defaultValue;
	}
	public class SilkSphere : SoundMaker, IHitResponder
	{
		[CompilerGenerated]
		private sealed class <FlashWhite>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SilkSphere <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: 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_0040: Expected O, but got Unknown
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this._targetColor = Color.white;
					<>2__current = (object)new WaitForSeconds(0.08f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this._targetColor = Dim;
					return false;
				}
			}

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

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

		private SpriteRenderer _renderer;

		private Color _targetColor;

		private static readonly Color Dim = new Color(0.7f, 0.7f, 0.7f, 1f);

		private static AudioClip _use;

		public static void Init()
		{
			ResourceUtils.LoadClipResource("silk_sphere", delegate(AudioClip clip)
			{
				_use = clip;
			});
		}

		private void Start()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			_renderer = ((Component)this).GetComponent<SpriteRenderer>();
			_renderer.color = Dim;
			_targetColor = Dim;
		}

		private void Update()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			_renderer.color = Color.Lerp(_renderer.color, _targetColor, Time.deltaTime * 10f);
		}

		[IteratorStateMachine(typeof(<FlashWhite>d__7))]
		private IEnumerator FlashWhite()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FlashWhite>d__7(0)
			{
				<>4__this = this
			};
		}

		public HitResponse Hit(HitInstance damageInstance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (!((HitInstance)(ref damageInstance)).IsNailDamage || !damageInstance.IsHeroDamage)
			{
				return HitResponse.op_Implicit((Response)0);
			}
			HeroController.instance.AddSilk(1, true);
			((MonoBehaviour)this).StartCoroutine(FlashWhite());
			PlaySound(_use, 10f, Random.Range(1f, 1.2f));
			return HitResponse.op_Implicit((Response)1);
		}
	}
	public class SoundMaker : MonoBehaviour
	{
		protected AudioSource Source;

		public bool muted;

		public virtual void Awake()
		{
			if (!muted)
			{
				Source = ((Component)this).gameObject.GetOrAddComponent<AudioSource>();
				Source.minDistance = 10f;
			}
		}

		public void PlaySound(AudioClip clip, float volume = 1f, float pitch = 1f, bool global = false, bool loop = false, bool setVol = true)
		{
			if (!muted)
			{
				Source.spatialBlend = ((!global) ? 1 : 0);
				Source.pitch = pitch;
				Source.clip = clip;
				if (setVol)
				{
					Source.volume = volume * GameManager.instance.GetImplicitCinematicVolume();
				}
				Source.loop = loop;
				Source.Play();
			}
		}
	}
	public class VelocityApplier : MonoBehaviour
	{
		public float x;

		public float y;

		private bool _started;

		private void Update()
		{
			if (!_started)
			{
				_started = true;
				Rigidbody2D component = ((Component)this).GetComponent<Rigidbody2D>();
				component.linearVelocityX = x;
				component.linearVelocityY = y;
			}
		}
	}
	public class WhiteSpikes : SoundMaker
	{
		private const float BOT_Y = -5.5f;

		private const float TOP_Y = 0f;

		private const float UP_TIME = 0.35f;

		private const float DOWN_TIME = 0.35f;

		private float _target;

		private float _bouncePoint;

		public float shiftDelay;

		public bool up;

		public float speed;

		private static readonly Sprite Top = ResourceUtils.LoadSpriteResource("Spikes.spikes_top", (FilterMode)1, default(Vector4), 64f);

		private static readonly Sprite Moving = ResourceUtils.LoadSpriteResource("Spikes.spikes_moving", (FilterMode)1, default(Vector4), 64f);

		private static AudioClip _upSound;

		private static AudioClip _downSound;

		private SpriteRenderer _renderer;

		private Collider2D _damageCollider;

		public static void Init()
		{
			ResourceUtils.LoadClipResource("Spikes.spikes_up", delegate(AudioClip clip)
			{
				_upSound = clip;
			});
			ResourceUtils.LoadClipResource("Spikes.spikes_down", delegate(AudioClip clip)
			{
				_downSound = clip;
			});
		}

		private void Start()
		{
			_renderer = ((Component)this).GetComponent<SpriteRenderer>();
			_damageCollider = ((Component)this).GetComponentInChildren<Collider2D>();
			_renderer.sprite = ((shiftDelay > 0f) ? Moving : Top);
			if (!up)
			{
				Extensions.SetLocalPositionY(((Component)this).transform, -5.5f);
				_target = 0f;
			}
			else
			{
				_target = -5.5f;
			}
		}

		private void Update()
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			if (_bouncePoint > 0f)
			{
				Extensions.SetLocalPositionY(((Component)this).transform, Mathf.Sin(MathF.PI / 180f * _bouncePoint) / 5f);
				_bouncePoint -= Time.deltaTime * 2500f * speed;
				if (_bouncePoint <= 0f)
				{
					_renderer.sprite = Top;
				}
				return;
			}
			if (shiftDelay > 0f)
			{
				shiftDelay -= Time.deltaTime * speed;
				if (!(shiftDelay <= 0f))
				{
					return;
				}
				if (up)
				{
					_bouncePoint = 180f;
					PlaySound(_downSound, 5f);
					_target = -5.5f;
					return;
				}
				((Behaviour)_damageCollider).enabled = true;
				_renderer.sprite = Moving;
				PlaySound(_upSound, 5f);
				_target = 0f;
			}
			Extensions.SetLocalPositionY(((Component)this).transform, ((Component)this).transform.localPosition.y + (up ? (0f - speed) : speed) * Time.deltaTime * 35f);
			if (_target < 0f)
			{
				if (((Component)this).transform.localPosition.y <= -5.5f)
				{
					Extensions.SetLocalPositionY(((Component)this).transform, -5.5f);
					shiftDelay = 0.35f;
					up = false;
					((Behaviour)_damageCollider).enabled = false;
				}
			}
			else if (((Component)this).transform.localPosition.y >= 0f)
			{
				Extensions.SetLocalPositionY(((Component)this).transform, 0f);
				_bouncePoint = 180f;
				shiftDelay = 0.35f;
				up = true;
			}
		}
	}
	public class Wind : MonoBehaviour
	{
		private static readonly int EnemyLayer = LayerMask.NameToLayer("Enemies");

		private static readonly int ProjectileLayer = LayerMask.NameToLayer("Projectiles");

		private static readonly int AttackLayer1 = LayerMask.NameToLayer("Enemy Attack");

		private static readonly int AttackLayer2 = LayerMask.NameToLayer("Attack");

		private static readonly Material WindMaterial = new Material(Shader.Find("Sprites/Default"))
		{
			mainTexture = (Texture)(object)ResourceUtils.LoadSpriteResource("wind_particle", (FilterMode)0).texture
		};

		public static bool ActuallyJumping;

		private static bool _windPlayer;

		public float speed = 30f;

		public float r = 1f;

		public float g = 1f;

		public float b = 1f;

		public float a = 1f;

		public bool affectsPlayer = true;

		public bool affectsEnemies = true;

		public bool affectsProjectiles = true;

		private EmissionModule? _emission;

		private MainModule? _main;

		private bool _setForce;

		private Vector3 _force;

		private Vector3 _wallForce;

		private void Update()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00ac: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!_setForce)
			{
				_setForce = true;
				if (((Component)this).transform.localScale.x < 0f)
				{
					speed = 0f - speed;
				}
				if (_emission.HasValue)
				{
					EmissionModule value = _emission.Value;
					((EmissionModule)(ref value)).rateOverTimeMultiplier = ((EmissionModule)(ref value)).rateOverTimeMultiplier * ((Component)this).transform.localScale.y;
				}
			}
			if (_main.HasValue)
			{
				MainModule value2 = _main.Value;
				Quaternion localRotation = ((Component)this).transform.localRotation;
				((MainModule)(ref value2)).startRotationMultiplier = MathF.PI / 180f * (0f - ((Quaternion)(ref localRotation)).eulerAngles.z);
			}
			_force = ((Component)this).transform.localRotation * new Vector3(speed, 0f, 0f);
			_wallForce = new Vector3(0f, _force.y, 0f);
		}

		public void OnTriggerExit2D(Collider2D other)
		{
			if (Object.op_Implicit((Object)(object)((Component)other).GetComponent<HeroController>()))
			{
				_windPlayer = false;
			}
		}

		public void OnTriggerStay2D(Collider2D other)
		{
			//IL_00b5: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if ((!affectsEnemies && ((Component)other).gameObject.layer == EnemyLayer) || (!affectsProjectiles && (((Component)other).gameObject.layer == ProjectileLayer || ((Component)other).gameObject.layer == AttackLayer1 || ((Component)other).gameObject.layer == AttackLayer2)))
			{
				return;
			}
			Rigidbody2D component = ((Component)other).GetComponent<Rigidbody2D>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			HeroController component2 = ((Component)other).GetComponent<HeroController>();
			if (!affectsPlayer && Object.op_Implicit((Object)(object)component2))
			{
				return;
			}
			Vector3 val = _force;
			if (Object.op_Implicit((Object)(object)component2))
			{
				if (component2.cState.touchingWall)
				{
					val = _wallForce;
				}
				if (component2.fsm_brollyControl.ActiveStateName == "Float Idle")
				{
					val.y /= 3f;
				}
				else if (component2.controlReqlinquished)
				{
					if (_windPlayer)
					{
						component.linearVelocity = Vector2.zero;
						_windPlayer = false;
					}
					return;
				}
			}
			component.AddForce(Vector2.op_Implicit(val));
			if (!Object.op_Implicit((Object)(object)component2))
			{
				return;
			}
			_windPlayer = true;
			if (_force.y > 0f)
			{
				component2.ResetHardLandingTimer();
				if (_force.y > 9f && !component2.cState.jumping && !component2.cState.doubleJumping && !component2.cState.wallJumping)
				{
					ActuallyJumping = false;
				}
			}
			if (component2.cState.onGround && !component2.CheckTouchingGround())
			{
				component2.cState.onGround = false;
				component2.cState.falling = true;
				component2.proxyFSM.SendEvent("HeroCtrl-LeftGround");
				component2.SetState((ActorStates)3);
			}
		}

		public static void Init()
		{
			Physics2D.IgnoreLayerCollision(6, LayerMask.NameToLayer("Enemy Detector"));
			Physics2D.IgnoreLayerCollision(6, LayerMask.NameToLayer("Hero Detector"));
			Physics2D.IgnoreLayerCollision(6, LayerMask.NameToLayer("Interactive Object"));
			HookUtils.OnHeroUpdate = (Action<HeroController>)Delegate.Combine(HookUtils.OnHeroUpdate, (Action<HeroController>)delegate
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				if (HeroController.instance.cState.jumping || HeroController.instance.cState.doubleJumping || HeroController.instance.cState.wallJumping)
				{
					ActuallyJumping = true;
				}
				else if (((Component)HeroController.instance).GetComponent<Rigidbody2D>().linearVelocity.y <= 0f)
				{
					ActuallyJumping = false;
				}
			});
			typeof(HeroController).Hook("BackOnGround", (Action<Action<HeroController, bool>, HeroController, bool>)delegate(Action<HeroController, bool> orig, HeroController self, bool force)
			{
				ActuallyJumping = false;
				orig(self, force);
			});
			typeof(HeroController).Hook("JumpReleased", (Action<Action<HeroController>, HeroController>)delegate(Action<HeroController> orig, HeroController self)
			{
				if (!ActuallyJumping)
				{
					self.jumpQueuing = false;
					self.doubleJumpQueuing = false;
				}
				else
				{
					orig(self);
				}
			});
		}

		public void SetupParticles()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Particles");
			val.transform.SetParent(((Component)this).transform, false);
			Transform transform = val.transform;
			transform.localPosition -= new Vector3(5f, 0f, 0f);
			val.layer = LayerMask.NameToLayer("Particle");
			ParticleSystem val2 = val.AddComponent<ParticleSystem>();
			MainModule main = val2.main;
			((MainModule)(ref main)).scalingMode = (ParticleSystemScalingMode)2;
			((MainModule)(ref main)).startLifetimeMultiplier = 100000f;
			((MainModule)(ref main)).startSpeedMultiplier = Mathf.Sqrt(speed) * 2f;
			((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(r, g, b, a));
			EmissionModule emission = val2.emission;
			((EmissionModule)(ref emission)).rateOverTimeMultiplier = Mathf.Sqrt(speed);
			_emission = emission;
			_main = main;
			ShapeModule shape = val2.shape;
			((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)18;
			((ShapeModule)(ref shape)).scale = new Vector3(10f, 1f, 10f);
			((ShapeModule)(ref shape)).rotation = new Vector3(0f, 90f, 270f);
			TriggerModule trigger = val2.trigger;
			((TriggerModule)(ref trigger)).enabled = true;
			BoxCollider2D val3 = val.AddComponent<BoxCollider2D>();
			((Collider2D)val3).offset = new Vector2(5f, 0f);
			val3.size = new Vector2(10f, 10f);
			((TriggerModule)(ref trigger)).AddCollider((Component)(object)val3);
			((TriggerModule)(ref trigger)).inside = (ParticleSystemOverlapAction)0;
			((TriggerModule)(ref trigger)).outside = (ParticleSystemOverlapAction)1;
			((Renderer)((Component)val2).GetComponent<ParticleSystemRenderer>()).material = WindMaterial;
		}
	}
}
namespace Architect.Behaviour.Abilities
{
	public class AbilityCrystal : SoundMaker
	{
		public int count;

		public string type;

		public bool singleUse;

		public float regenTime;

		private SpriteRenderer _renderer;

		private FloatAnim _float;

		private Sprite _activeSprite;

		private Sprite _inactiveSprite;

		private float _remainingTime;

		private static readonly Sprite SingleUsed = ResourceUtils.LoadSpriteResource("Crystals.used_s", (FilterMode)0, default(Vector4), 15f);

		private static readonly Sprite DoubleUsed = ResourceUtils.LoadSpriteResource("Crystals.used_m", (FilterMode)0, default(Vector4), 15f);

		private static readonly Sprite TripleUsed = ResourceUtils.LoadSpriteResource("Crystals.used_l", (FilterMode)0, default(Vector4), 15f);

		private static AudioClip _use;

		private static AudioClip _regen;

		public static void Init()
		{
			ResourceUtils.LoadClipResource("Crystals.use", delegate(AudioClip clip)
			{
				_use = clip;
			});
			ResourceUtils.LoadClipResource("Crystals.regen", delegate(AudioClip clip)
			{
				_regen = clip;
			});
		}

		private void Start()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			_renderer = ((Component)this).GetComponentInChildren<SpriteRenderer>();
			_float = ((Component)this).GetComponentInChildren<FloatAnim>();
			_activeSprite = _renderer.sprite;
			int num = count;
			if (1 == 0)
			{
			}
			Sprite inactiveSprite = (Sprite)(num switch
			{
				1 => SingleUsed, 
				2 => DoubleUsed, 
				_ => TripleUsed, 
			});
			if (1 == 0)
			{
			}
			_inactiveSprite = inactiveSprite;
			if (singleUse)
			{
				_renderer.color = new Color(1f, 0.5f, 0.5f, 1f);
			}
		}

		private void Update()
		{
			if (_remainingTime > 0f)
			{
				_remainingTime -= Time.deltaTime;
				if (_remainingTime <= 0f)
				{
					_renderer.sprite = _activeSprite;
					((Component)this).gameObject.BroadcastEvent("OnRegen");
					_float.active = true;
					PlaySound(_regen, 5f);
				}
			}
		}

		private void OnTriggerStay2D(Collider2D other)
		{
			if (!(_remainingTime > 0f) && Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<HeroController>()))
			{
				AbilityObjects.ActiveCrystals[type] = Math.Max(count, AbilityObjects.ActiveCrystals.GetValueOrDefault(type, 0));
				if (singleUse)
				{
					((Component)this).gameObject.SetActive(false);
				}
				else if (regenTime > 0f)
				{
					_renderer.sprite = _inactiveSprite;
					_remainingTime = regenTime;
					_float.active = false;
				}
				((Component)this).gameObject.BroadcastEvent("OnCollect");
				PlaySound(_use, 5f);
				AbilityObjects.RefreshCrystalUI();
			}
		}
	}
	public class Binding : SoundMaker
	{
		public string bindingType;

		public Sprite disabledSprite;

		public Sprite enabledSprite;

		public bool active;

		public bool reversible;

		public bool uiVisible = true;

		private SpriteRenderer _renderer;

		private bool _used;

		private static AudioClip _use;

		public static void Init()
		{
			ResourceUtils.LoadClipResource("Bindings.use", delegate(AudioClip clip)
			{
				_use = clip;
			});
		}

		private void Start()
		{
			_renderer = ((Component)this).GetComponent<SpriteRenderer>();
			if (!AbilityObjects.ActiveBindings.TryGetValue(bindingType, out var value))
			{
				value = new List<Binding>();
				AbilityObjects.ActiveBindings[bindingType] = value;
			}
			value.Add(this);
			if (uiVisible)
			{
				if (!AbilityObjects.ActiveVisibleBindings.TryGetValue(bindingType, out var value2))
				{
					value2 = new List<Binding>();
					AbilityObjects.ActiveVisibleBindings[bindingType] = value2;
				}
				value2.Add(this);
			}
			_renderer.sprite = (active ? enabledSprite : disabledSprite);
			OnToggle();
		}

		private void OnEnable()
		{
			OnToggle();
		}

		private void OnDisable()
		{
			OnToggle();
		}

		private void OnTriggerEnter2D(Collider2D other)
		{
			if (!_used && Object.op_Implicit((Object)(object)((Component)other).gameObject.GetComponent<HeroController>()))
			{
				active = !active;
				if (active)
				{
					_renderer.sprite = enabledSprite;
					EventManager.BroadcastEvent(((Component)this).gameObject, "OnBind");
				}
				else
				{
					_renderer.sprite = disabledSprite;
					EventManager.BroadcastEvent(((Component)this).gameObject, "OnUnbind");
				}
				PlaySound(_use, 2f);
				OnToggle();
				if (!reversible)
				{
					_used = true;
					((Renderer)_renderer).enabled = false;
				}
			}
		}

		public virtual void OnToggle()
		{
			AbilityObjects.RefreshBindingUI();
		}
	}
	public class CrestBinding : Binding
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass6_0
		{
			public HeroController hc;

			internal bool <RefreshCrestWhenReady>b__0()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Invalid comparison between Unknown and I4
				return !hc.controlReqlinquished && !hc.cState.dashing && !hc.cState.downAttacking && !hc.cState.downSpikeAntic && !hc.cState.airDashing && (int)HeroController.instance.transitionState == 0;
			}
		}

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

			private object <>2__current;

			private <>c__DisplayClass6_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass6_0();
					<>8__1.hc = HeroController.instance;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => !<>8__1.hc.controlReqlinquished && !<>8__1.hc.cState.dashing && !<>8__1.hc.cState.downAttacking && !<>8__1.hc.cState.downSpikeAntic && !<>8__1.hc.cState.airDashing && (int)HeroController.instance.transitionState == 0));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					RefreshCrest();
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>8__1.hc.RegainControl();
					<>8__1.hc.StartAnimationControl();
					return false;
				}
			}

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

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

		private static bool _isOverridingCrest;

		private static string _actualCrest;

		private static string _forcedCrest;

		public static void InitCrestBindings()
		{
			typeof(ToolItemManager).Hook("SetEquippedCrest", (Action<Action<string>, string>)delegate(Action<string> orig, string crest)
			{
				if (_isOverridingCrest && crest != _forcedCrest)
				{
					_actualCrest = crest;
					PlayerData.instance.PreviousCrestID = crest;
				}
				else
				{
					orig(crest);
				}
			});
			typeof(ToolItemManager).Hook("SendEquippedChangedEvent", (Action<Action<bool>, bool>)delegate(Action<bool> orig, bool force)
			{
				if (!_isOverridingCrest || !(PlayerData.instance.CurrentCrestID != _forcedCrest))
				{
					orig(force);
				}
			});
			typeof(GameManager).Hook("SaveGame", (Action<Action<GameManager, int, Action<bool>, bool, AutoSaveName>, GameManager, int, Action<bool>, bool, AutoSaveName>)delegate(Action<GameManager, int, Action<bool>, bool, AutoSaveName> orig, GameManager self, int saveSlot, Action<bool> ogCallback, bool withAutoSave, AutoSaveName autoSaveName)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				ogCallback = (Action<bool>)Delegate.Combine(ogCallback, (Action<bool>)delegate
				{
					RefreshCrest();
				});
				orig(self, saveSlot, ogCallback, withAutoSave, autoSaveName);
			}, typeof(int), typeof(Action<bool>), typeof(bool), typeof(AutoSaveName));
		}

		public static void InitItcHook()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			new Hook((MethodBase)typeof(InventoryToolCrest).GetProperty("IsHidden").GetGetMethod(), (Delegate)(Func<Func<InventoryToolCrest, bool>, InventoryToolCrest, bool>)((Func<InventoryToolCrest, bool> orig, InventoryToolCrest self) => orig(self) || _isOverridingCrest));
		}

		public override void OnToggle()
		{
			base.OnToggle();
			((MonoBehaviour)ArchitectPlugin.Instance).StartCoroutine(RefreshCrestWhenReady());
		}

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

		private static void RefreshCrest()
		{
			PlayerData instance = PlayerData.instance;
			bool isOverridingCrest = _isOverridingCrest;
			(string, Sprite)? activeCrestBinding = AbilityObjects.GetActiveCrestBinding();
			if (activeCrestBinding.HasValue)
			{
				_isOverridingCrest = true;
				if (!isOverridingCrest)
				{
					_actualCrest = (instance.IsCurrentCrestTemp ? instance.PreviousCrestID : instance.CurrentCrestID);
				}
				_forcedCrest = activeCrestBinding.Value.Item1;
				ToolCrest crestByName = ToolItemManager.GetCrestByName(_forcedCrest);
				instance.IsCurrentCrestTemp = true;
				ToolItemManager.AutoEquip(crestByName, false, false);
				instance.IsCurrentCrestTemp = true;
				instance.PreviousCrestID = _actualCrest;
				HeroController.instance.UpdateSilkCursed();
			}
			else if (isOverridingCrest)
			{
				_isOverridingCrest = false;
				ToolItemManager.AutoEquip(ToolItemManager.GetCrestByName(_actualCrest), false, false);
				HeroController.instance.UpdateSilkCursed();
			}
		}
	}
	public class ToolBinding : Binding
	{
		public static void InitToolBindings()
		{
		}
	}
}
namespace Architect.Api
{
	public static class EventHooks
	{
		public static Action<GameObject, string> OnEvent;

		public static void AddEvent(GameObject obj, string triggerName, string eventName)
		{
			LegacyBroadcaster legacyBroadcaster = obj.AddComponent<LegacyBroadcaster>();
			legacyBroadcaster.triggerName = triggerName;
			legacyBroadcaster.eventName = eventName;
		}
	}
	public static class MapLoader
	{
		private static readonly Dictionary<string, Dictionary<Assembly, string>> ModMaps = new Dictionary<string, Dictionary<Assembly, string>>();

		private static readonly Dictionary<string, List<string>> StandaloneMaps = new Dictionary<string, List<string>>();

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

		private static readonly Dictionary<string, HashSet<Func<LevelData>>> ExtMapLoadersByScene = new Dictionary<string, HashSet<Func<LevelData>>>();

		private static readonly HashSet<Func<string, LevelData>> ExtMapLoaders = new HashSet<Func<string, LevelData>>();

		public static void LoadMap(Assembly asm, string sceneName, string mapPath)
		{
			if (!ModMaps.ContainsKey(sceneName))
			{
				ModMaps[sceneName] = new Dictionary<Assembly, string>();
			}
			ModMaps[sceneName][asm] = mapPath;
		}

		public static void LoadStandaloneMap(string sceneName, string mapPath)
		{
			if (!StandaloneMaps.ContainsKey(sceneName))
			{
				StandaloneMaps[sceneName] = new List<string>();
			}
			StandaloneMaps[sceneName].Add(mapPath);
		}

		public static void LoadStandalonePrefab(string prefabName, string mapPath)
		{
			StandalonePrefabs[prefabName] = mapPath;
		}

		public static string GetPrefab(string prefabName)
		{
			return StandalonePrefabs.GetValueOrDefault(prefabName);
		}

		public static void AddMapLoader(string scene, Func<LevelData> mapLoader)
		{
			if (ExtMapLoadersByScene.TryGetValue(scene, out var value))
			{
				value.Add(mapLoader);
				return;
			}
			ExtMapLoadersByScene.Add(scene, new HashSet<Func<LevelData>> { mapLoader });
		}

		public static void RemoveMapLoader(string scene, Func<LevelData> mapLoader)
		{
			if (ExtMapLoadersByScene.TryGetValue(scene, out var value) && value.Remove(mapLoader) && value.Count == 0)
			{
				ExtMapLoadersByScene.Remove(scene);
			}
		}

		public static void AddMapLoader(Func<string, LevelData> mapLoader)
		{
			ExtMapLoaders.Add(mapLoader);
		}

		public static void RemoveMapLoader(Func<string, LevelData> mapLoader)
		{
			ExtMapLoaders.Remove(mapLoader);
		}

		public static LevelData GetModData(string scene)
		{
			LevelData levelData = new LevelData(new List<ObjectPlacement>(), new List<(int, int)>(), new List<ScriptBlock>(), new List<Comment>());
			foreach (Func<string, LevelData> mapLoader in ExtMapLoaders)
			{
				TryLoadMap(() => mapLoader(scene));
			}
			if (ExtMapLoadersByScene.TryGetValue(scene, out var value))
			{
				foreach (Func<LevelData> item in value)
				{
					TryLoadMap(item);
				}
			}
			if (ModMaps.TryGetValue(scene, out var value2))
			{
				foreach (KeyValuePair<Assembly, string> item2 in value2)
				{
					var (asm, mapPath2) = (KeyValuePair<Assembly, string>)(ref item2);
					TryLoadMap(delegate
					{
						using Stream stream = asm.GetManifestResourceStream(mapPath2);
						if (stream == null)
						{
							return null;
						}
						byte[] array = new byte[stream.Length];
						stream.Read(array, 0, array.Length);
						string @string = Encoding.UTF8.GetString(array);
						return StorageManager.DeserializeLevel(@string);
					});
				}
			}
			if (StandaloneMaps.TryGetValue(scene, out var value3))
			{
				foreach (string mapPath in value3)
				{
					TryLoadMap(() => StorageManager.DeserializeLevel(File.ReadAllText(mapPath)));
				}
			}
			return levelData;
			void TryLoadMap(Func<LevelData> loader)
			{
				try
				{
					LevelData levelData2 = loader();
					if (levelData2 != null)
					{
						levelData.Merge(levelData2);
					}
				}
				catch (Exception arg)
				{
					ArchitectPlugin.Logger.LogError((object)$"External map loader failed on '{scene}': {arg}");
				}
			}
		}
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			return !_moveNextCalled && (_moveNextCalled = true);
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		return (!EqualityComparer<T>.Default.Equals(_item, (T)value)) ? (-1) : 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return (!EqualityComparer<T>.Default.Equals(_item, item)) ? (-1) : 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}