using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
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;
using System.Threading.Tasks;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.BounceFeatures.DeathLink;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.Models;
using Archipelago.MultiClient.Net.Packets;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using PulseLib;
using PulseLib.Extensions;
using PulseLib.Localization;
using RDLevelEditor;
using RhythmDoctor.Archipelago.Client;
using RhythmDoctor.Archipelago.Extensions;
using RhythmDoctor.Archipelago.Helpers;
using RhythmDoctor.Archipelago.Interfaces;
using RhythmDoctor.Archipelago.Patches;
using RhythmDoctor.Archipelago.Patches.Gameplay;
using RhythmDoctor.Archipelago.Patches.Gameplay.Powerups;
using RhythmDoctor.Archipelago.Patches.Gameplay.Traps;
using RhythmDoctor.Archipelago.Patches.Menu;
using RhythmDoctor.Archipelago.World;
using RhythmDoctor.Archipelago.World.Data;
using RhythmWeightlifter;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("gg.archipelago.rhythmdoctor")]
[assembly: AssemblyConfiguration("Release-BepInEx5")]
[assembly: AssemblyFileVersion("0.6.13.0")]
[assembly: AssemblyInformationalVersion("0.6.13+71162631dc2f6e169ab8e9362130d32633f21ee2")]
[assembly: AssemblyProduct("RhythmDoctor.Archipelago")]
[assembly: AssemblyTitle("gg.archipelago.rhythmdoctor")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.6.13.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[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()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		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)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 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)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	[AttributeUsage(AttributeTargets.All)]
	[ExcludeFromCodeCoverage]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace Archipelago.MultiClient.Net
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
	internal sealed class DataStoragePropertyAttribute : Attribute
	{
		public string? SessionVariable { get; }

		public Scope Scope { get; }

		public string Key { get; }

		public DataStoragePropertyAttribute(string sessionVariable, Scope scope, string key)
		{
			//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)
			SessionVariable = sessionVariable;
			Scope = scope;
			Key = key;
		}

		public DataStoragePropertyAttribute(string sessionVariable, string key)
			: this(sessionVariable, (Scope)0, key)
		{
		}
	}
}
namespace RhythmDoctor.Archipelago
{
	internal static class Configuration
	{
		internal enum DeathLinkConfig
		{
			FollowSlot,
			On,
			Off
		}

		private static ConfigEntry<DeathLinkConfig> _deathLink;

		private static ConfigEntry<int> _autoReconnectMaxRetries;

		private static ConfigEntry<int> _remoteTrapClearsTimeout;

		private static ConfigEntry<int> _slotToUse;

		internal static void Bind(ConfigFile config)
		{
			Plugin.Logger.LogInfo((object)"Binding configuration");
			_deathLink = config.Bind<DeathLinkConfig>("Gameplay", "DeathLink", DeathLinkConfig.FollowSlot, "Whether to enable DeathLink when connected to an Archipelago slot.\nSee the respective Game Page in Archipelago for more info.");
			_autoReconnectMaxRetries = config.Bind<int>("zzzDebugDoNotTouchUnlessAsked", "AutoReconnectMaxRetries", 3, "How many times to attempt to reconnect to an Archipelago server before the client is considered unsalvagable and the Client is abandoned.");
			_remoteTrapClearsTimeout = config.Bind<int>("zzzDebugDoNotTouchUnlessAsked", "RemoteTrapClearsTimeout", 3000, "How long to wait in milliseconds until getting remote trap clear status times out and defaults to 0/last known good value.");
			_slotToUse = config.Bind<int>("zzzDebugDoNotTouchUnlessAsked", "SlotToUse", 0, "Slot to use for Archipelago.");
		}

		internal static async Task<DeathLinkConfig> GetDeathLink()
		{
			if (Plugin.Client == null || Plugin.Client.Session == null)
			{
				return _deathLink.Value;
			}
			return (!(await ((IDataStorageWrapper)Plugin.Client.Session.DataStorage).GetRaceModeAsync())) ? _deathLink.Value : DeathLinkConfig.FollowSlot;
		}

		internal static int GetSlotToUse()
		{
			return _slotToUse.Value;
		}

		internal static int GetAutoReconnectMaxRetries()
		{
			return _autoReconnectMaxRetries.Value;
		}

		internal static int GetRemoteTrapClearsTimeout()
		{
			return _remoteTrapClearsTimeout.Value;
		}
	}
	internal static class Paths
	{
		internal static string Assembly;

		internal static string Assets;

		internal static string Localization;

		internal static string WardIcons;

		internal static void PopulatePaths()
		{
			Assembly = Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
			Assets = Path.Combine(Assembly, "Assets");
			Localization = Path.Combine(Assets, "Localization");
			WardIcons = Path.Combine(Assets, "WardIcons");
		}
	}
	[BepInPlugin("gg.archipelago.rhythmdoctor", "RhythmDoctor.Archipelago", "0.6.13")]
	[BepInDependency("io.github.nonperforming.pulse", "0.0.6")]
	[BepInProcess("Rhythm Doctor.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal static RhythmDoctor.Archipelago.Client.Client Client = null;

		internal static ManualLogSource Logger = null;

		internal static readonly Random Random = new Random();

		internal static readonly ConcurrentQueue<Action> ToExecuteOnMainThread = new ConcurrentQueue<Action>();

		internal static Plugin Instance = null;

		internal const string PATCH_ID_ALWAYS_ACTIVE = "gg.archipelago.rhythmdoctor";

		internal const string PATCH_ID_ARCHIPELAGO_MENU = "gg.archipelago.rhythmdoctor.cls";

		internal const string PATCH_ID_POST_LOGIN = "gg.archipelago.rhythmdoctor.post";

		internal const string PATCH_ID_TRAP = "gg.archipelago.rhythmdoctor.trap";

		internal const string PATCH_ID_SLEEVE_PAINT = "gg.archipelago.rhythmdoctor.sleevepaint";

		private static readonly Type[] AlwaysActivePatches = new Type[3]
		{
			typeof(ArchipelagoMainMenuOptionPatch),
			typeof(VersionTextPatch),
			typeof(scnGameExtensions)
		};

		private static readonly Type[] PostLoginPatches = new Type[15]
		{
			typeof(Act5Patch),
			typeof(ClearLocationPatch),
			typeof(DeathLinkPatch),
			typeof(LevelSelectVisualFixesPatch),
			typeof(RhythmDogtorLevelPatch),
			typeof(RhythmWeightlifterPatch),
			typeof(RunningCharactersPatch),
			typeof(SkipCutscenePatch),
			typeof(SkipTutorialPatch),
			typeof(StateReplicationPatch),
			typeof(TrapManagerPatch),
			typeof(UnlockItemPatch),
			typeof(WelcomeBackPatch),
			typeof(SavingPatch),
			typeof(UnapplyPatchesPatch)
		};

		private static readonly Type CustomLoginScreenPatch = typeof(ArchipelagoLoginPatch);

		private bool _quitting;

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"gg.archipelago.rhythmdoctor v0.6.13 loading");
			Configuration.Bind(((BaseUnityPlugin)this).Config);
			Logger.LogInfo((object)"Setting up paths");
			Paths.PopulatePaths();
			Logger.LogInfo((object)("Registering custom localization (" + Paths.Localization + ")"));
			CustomLocalizationHelper.SearchAndRegisterDirectory(Paths.Localization);
			Logger.LogInfo((object)"Applying always active patches");
			ApplyPatches("gg.archipelago.rhythmdoctor", AlwaysActivePatches);
			Logger.LogInfo((object)"gg.archipelago.rhythmdoctor v0.6.13 loaded");
		}

		private void Start()
		{
			Version version = new Version("1.1.1");
			Version version2 = new Version(Application.version);
			if (Releases.releaseNumber < 42 || version2 < version)
			{
				Logger.LogWarning((object)"================================================================================");
				Logger.LogWarning((object)"|   ╭─╮╷  ╭─╴╭─╮╭─╮╭─╴   ╷ ╷╭─╮╶┬╮╭─╮╶┬╴╭─╴   ╷ ╷╭─╮╷ ╷╭─╮   ╭─╴╭─╮╭┬╮╭─╴╷╷╷   |");
				Logger.LogWarning((object)"|   ├─╯│  ├╴ ├─┤╰─╮├╴    │ │├─╯ ││├─┤ │ ├╴    ╰┬╯│ ││ │├┬╯   │╶╮├─┤│││├╴ ╵╵╵   |");
				Logger.LogWarning((object)"|   ╵  ╰─╴╰─╴╵ ╵╰─╯╰─╴   ╰─╯╵  ╶┴╯╵ ╵ ╵ ╰─╴    ╵ ╰─╯╰─╯╵╰╴   ╰─╯╵ ╵╵ ╵╰─╴╵╵╵   |");
				Logger.LogWarning((object)"================================================================================");
				Logger.LogWarning((object)string.Format("This version of the mod (v{0}) was built for: v{1} (release {2}, commit {3}, date {4})", "0.6.13", version, 42, "e43207b", "2026/06/15 12:42 AM"));
				Logger.LogWarning((object)$"Your version is: v{Application.version} (release {Releases.releaseNumber}, commit {Releases.buildCommit}, date {Releases.buildDate})");
				Logger.LogWarning((object)"================================================================================");
			}
			else if (Releases.releaseNumber > 42 || version2 > version)
			{
				Logger.LogWarning((object)"=================================================================================");
				Logger.LogWarning((object)"|         ╭─╮╷  ╭─╴╭─╮╭─╮╭─╴   ╭─╮╭─╮╭─╴╭╮╷   ╭─╮╭╮╷   ╷╭─╮╭─╮╷ ╷╭─╴╷╷╷         |");
				Logger.LogWarning((object)"|         ├─╯│  ├╴ ├─┤╰─╮├╴    │ │├─╯├╴ │╰┤   ├─┤│╰┤   │╰─╮╰─╮│ │├╴ ╵╵╵         |");
				Logger.LogWarning((object)"|         ╵  ╰─╴╰─╴╵ ╵╰─╯╰─╴   ╰─╯╵  ╰─╴╵ ╵   ╵ ╵╵ ╵   ╵╰─╯╰─╯╰─╯╰─╴╵╵╵         |");
				Logger.LogWarning((object)"=================================================================================");
				Logger.LogWarning((object)string.Format("This version of the mod (v{0}) was built for: v{1} (release {2}, commit {3}, date {4})", "0.6.13", version, 42, "e43207b", "2026/06/15 12:42 AM"));
				Logger.LogWarning((object)$"Your version is: v{Application.version} (release {Releases.releaseNumber}, commit {Releases.buildCommit}, date {Releases.buildDate})");
				Logger.LogWarning((object)null);
				Logger.LogWarning((object)"First, please check that there is an updated version here: https://github.com/nonperforming/RhythmDoctor.Archipelago/releases. Remember to update Pulse (https://github.com/nonperforming/Pulse/releases) as well.");
				Logger.LogWarning((object)$"If there is no update yet, please open an issue at https://github.com/nonperforming/RhythmDoctor.Archipelago/issues/new?labels=\"plugin outdated\"&title=v{Application.version}+support&body=Release:+{Releases.releaseNumber}+/+Commit:+{Releases.buildCommit}+/+Date:+{Releases.buildDate}&assignees=nonperforming");
				Logger.LogWarning((object)"=================================================================================");
			}
		}

		private void Update()
		{
			Action result;
			while (ToExecuteOnMainThread.TryDequeue(out result))
			{
				result();
			}
		}

		private static void ApplyPatches(string id, params Type[] patches)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			Logger.LogInfo((object)("Applying patches as " + id));
			Harmony val = new Harmony(id);
			foreach (Type type in patches)
			{
				Logger.LogInfo((object)("Applying " + type.Name));
				val.PatchAll(type);
			}
		}

		internal static void ApplyGameplayPatches()
		{
			Logger.LogInfo((object)"Applying gameplay patches");
			ApplyPatches("gg.archipelago.rhythmdoctor.post", PostLoginPatches);
			ApplyPatches("gg.archipelago.rhythmdoctor.sleevepaint", typeof(LockSleevePaintPatch));
		}

		internal static void UnapplyGameplayPatches()
		{
			Logger.LogInfo((object)"Unapplying gameplay patches");
			Harmony.UnpatchID("gg.archipelago.rhythmdoctor.post");
			Harmony.UnpatchID("gg.archipelago.rhythmdoctor.sleevepaint");
		}

		internal static void ApplyArchipelagoMenuPatch()
		{
			Logger.LogInfo((object)"Applying Archipelago menu patch");
			Harmony.CreateAndPatchAll(CustomLoginScreenPatch, "gg.archipelago.rhythmdoctor.cls");
		}

		internal static void UnapplyArchipelagoMenuPatch()
		{
			Logger.LogInfo((object)"Unapplying Archipelago menu patch");
			Harmony.UnpatchID("gg.archipelago.rhythmdoctor.cls");
		}

		private void OnApplicationQuit()
		{
			Logger.LogDebug((object)"Quitting...");
			_quitting = true;
		}

		private void OnDestroy()
		{
			if (!_quitting)
			{
				Logger.LogWarning((object)"Tearing down plugin. This is unsupported!");
				UnapplyPatchesPatch.TearDownClientPluginPatch();
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor");
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor.cls");
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor.post");
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor.trap");
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "gg.archipelago.rhythmdoctor";

		public const string PLUGIN_NAME = "RhythmDoctor.Archipelago";

		public const string PLUGIN_VERSION = "0.6.13";
	}
}
namespace RhythmDoctor.Archipelago.World
{
	internal enum Act
	{
		None,
		Act1,
		Act2,
		Act3,
		Act4,
		Act5,
		Act6,
		Act7
	}
	internal static class Bindings
	{
		internal const string GAME = "Rhythm Doctor";

		internal const long SLEEVE_PAINT_ITEM_ID = 56L;

		internal const Level RHYTHM_DOGTOR_LEVEL = (Level)84;

		internal static readonly Dictionary<Level, BaseStage> LevelToStage = new Dictionary<Level, BaseStage>
		{
			{
				(Level)2,
				new RegularStage(Act.Act1, 1L, 2L, 3L)
			},
			{
				(Level)3,
				new RegularStage(Act.Act1, 4L, 5L, 6L)
			},
			{
				(Level)4,
				new RegularStage(Act.Act1, 7L, 8L, 9L)
			},
			{
				(Level)5,
				new RegularStage(Act.Act1, 10L, 11L, 12L)
			},
			{
				(Level)53,
				new RegularStage(Act.Act1, 13L, 14L, 15L)
			},
			{
				(Level)54,
				new RegularStage(Act.Act1, 16L, 17L, 18L)
			},
			{
				(Level)18,
				new RegularStage(Act.Act3, 21L, 22L, 23L)
			},
			{
				(Level)19,
				new RegularStage(Act.Act3, 24L, 25L, 26L)
			},
			{
				(Level)20,
				new RegularStage(Act.Act3, 27L, 28L, 29L)
			},
			{
				(Level)21,
				new RegularStage(Act.Act3, 30L, 31L, 32L)
			},
			{
				(Level)22,
				new RegularStage(Act.Act3, 33L, 34L, 35L)
			},
			{
				(Level)23,
				new RegularStage(Act.Act3, 36L, 37L, 38L)
			},
			{
				(Level)26,
				new BossStage(Act.Act3, 39L, null, 40L)
			},
			{
				(Level)84,
				new BossStage(Act.Act3, 41L, null, 42L)
			},
			{
				(Level)8,
				new RegularStage(Act.Act2, 43L, 44L, 45L)
			},
			{
				(Level)9,
				new RegularStage(Act.Act2, 46L, 47L, 48L)
			},
			{
				(Level)10,
				new RegularStage(Act.Act2, 49L, 50L, 51L)
			},
			{
				(Level)11,
				new RegularStage(Act.Act2, 52L, 53L, 54L)
			},
			{
				(Level)12,
				new RegularStage(Act.Act2, 55L, 56L, 57L)
			},
			{
				(Level)13,
				new RegularStage(Act.Act2, 58L, 59L, 60L)
			},
			{
				(Level)14,
				new RegularStage(Act.Act2, 171L, 172L, 61L)
			},
			{
				(Level)15,
				new RegularStage(Act.Act2, 173L, 174L, 62L)
			},
			{
				(Level)17,
				new RegularStage(Act.Act2, 63L, 64L, 65L)
			},
			{
				(Level)48,
				new BossStage(Act.Act7, 66L, 67L, 68L)
			},
			{
				(Level)27,
				new RegularStage(Act.Act4, 71L, 72L, 73L)
			},
			{
				(Level)28,
				new RegularStage(Act.Act4, 74L, 75L, 76L)
			},
			{
				(Level)29,
				new RegularStage(Act.Act4, 77L, 78L, 79L)
			},
			{
				(Level)30,
				new RegularStage(Act.Act4, 80L, 81L, 82L)
			},
			{
				(Level)31,
				new RegularStage(Act.Act4, 83L, 84L, 85L)
			},
			{
				(Level)32,
				new RegularStage(Act.Act4, 86L, 87L, 88L)
			},
			{
				(Level)33,
				new RegularStage(Act.Act4, 89L, 90L, 91L)
			},
			{
				(Level)34,
				new RegularStage(Act.Act4, 92L, 93L, 94L)
			},
			{
				(Level)35,
				new RegularStage(Act.Act5, 97L, 98L, 99L)
			},
			{
				(Level)36,
				new RegularStage(Act.Act5, 100L, 101L, 102L)
			},
			{
				(Level)37,
				new RegularStage(Act.Act5, 103L, 104L, 105L)
			},
			{
				(Level)38,
				new RegularStage(Act.Act5, 106L, 107L, 108L)
			},
			{
				(Level)39,
				new RegularStage(Act.Act5, 175L, 176L, 109L)
			},
			{
				(Level)40,
				new RegularStage(Act.Act5, 110L, 111L, 112L)
			},
			{
				(Level)43,
				new RegularStage(Act.Act6, 126L, 127L, 128L)
			},
			{
				(Level)45,
				new RegularStage(Act.Act6, 129L, 130L, 131L)
			},
			{
				(Level)47,
				new RegularStage(Act.Act7, 135L, 136L, 137L)
			},
			{
				(Level)58,
				new RegularStage(Act.None, 144L, 145L, 146L)
			},
			{
				(Level)59,
				new RegularStage(Act.None, 147L, 148L, 149L)
			},
			{
				(Level)56,
				new RegularStage(Act.None, 150L, 151L, 152L)
			},
			{
				(Level)57,
				new RegularStage(Act.None, 153L, 154L, 155L)
			},
			{
				(Level)61,
				new RegularStage(Act.None, 156L, 157L, 158L)
			},
			{
				(Level)62,
				new RegularStage(Act.None, 159L, 160L, 161L)
			},
			{
				(Level)63,
				new RegularStage(Act.None, 162L, 163L, 164L)
			},
			{
				(Level)55,
				new RegularStage(Act.None, 165L, 166L, 167L)
			},
			{
				(Level)25,
				new RegularStage(Act.None, 168L, 169L, 170L)
			},
			{
				(Level)60,
				new RegularStage(Act.None, 177L, 178L, 179L)
			},
			{
				(Level)6,
				new BossStage(Act.Act1, 19L, null, 20L)
			},
			{
				(Level)16,
				new BossStage(Act.Act2, 69L, null, 70L)
			},
			{
				(Level)7,
				new BossStage(Act.Act4, 95L, null, 96L)
			},
			{
				(Level)42,
				new BossStage(Act.Act5, 123L, 124L, 125L)
			},
			{
				(Level)46,
				new BossStage(Act.Act6, 132L, null, 134L)
			},
			{
				(Level)49,
				new BossStage(Act.Act7, 138L, 139L, 140L)
			},
			{
				(Level)50,
				new BossStage(Act.Act7, 141L, 142L, 143L)
			}
		};

		internal static readonly Dictionary<long, Level> ItemIdToLevel = new Dictionary<long, Level>
		{
			{
				1L,
				(Level)2
			},
			{
				2L,
				(Level)3
			},
			{
				3L,
				(Level)4
			},
			{
				4L,
				(Level)5
			},
			{
				5L,
				(Level)53
			},
			{
				6L,
				(Level)54
			},
			{
				7L,
				(Level)18
			},
			{
				8L,
				(Level)19
			},
			{
				9L,
				(Level)20
			},
			{
				10L,
				(Level)21
			},
			{
				11L,
				(Level)22
			},
			{
				12L,
				(Level)23
			},
			{
				13L,
				(Level)8
			},
			{
				14L,
				(Level)9
			},
			{
				15L,
				(Level)10
			},
			{
				16L,
				(Level)11
			},
			{
				17L,
				(Level)12
			},
			{
				18L,
				(Level)13
			},
			{
				19L,
				(Level)14
			},
			{
				20L,
				(Level)15
			},
			{
				21L,
				(Level)17
			},
			{
				22L,
				(Level)48
			},
			{
				23L,
				(Level)27
			},
			{
				24L,
				(Level)28
			},
			{
				25L,
				(Level)29
			},
			{
				26L,
				(Level)30
			},
			{
				27L,
				(Level)31
			},
			{
				28L,
				(Level)32
			},
			{
				29L,
				(Level)33
			},
			{
				30L,
				(Level)34
			},
			{
				31L,
				(Level)35
			},
			{
				32L,
				(Level)36
			},
			{
				33L,
				(Level)37
			},
			{
				34L,
				(Level)38
			},
			{
				35L,
				(Level)39
			},
			{
				36L,
				(Level)40
			},
			{
				37L,
				(Level)41
			},
			{
				38L,
				(Level)43
			},
			{
				39L,
				(Level)45
			},
			{
				40L,
				(Level)47
			},
			{
				41L,
				(Level)58
			},
			{
				42L,
				(Level)59
			},
			{
				43L,
				(Level)56
			},
			{
				44L,
				(Level)57
			},
			{
				45L,
				(Level)61
			},
			{
				46L,
				(Level)62
			},
			{
				47L,
				(Level)63
			},
			{
				48L,
				(Level)55
			},
			{
				49L,
				(Level)25
			},
			{
				67L,
				(Level)60
			}
		};

		internal static readonly Dictionary<long, Type> TrapItemIdToLevel = new Dictionary<long, Type>
		{
			{
				60L,
				typeof(FragileHeartTrapPatch)
			},
			{
				61L,
				typeof(HardDifficultyTrapPatch)
			},
			{
				62L,
				typeof(ScrambleCharactersTrapPatch)
			},
			{
				63L,
				typeof(ScrambleBeatsoundsTrapPatch)
			},
			{
				64L,
				typeof(ScrambleHitsoundsTrapPatch)
			},
			{
				65L,
				typeof(ChilliSpeedTrapPatch)
			},
			{
				66L,
				typeof(GhostTapTrapPatch)
			},
			{
				57L,
				typeof(StrongHeartPowerupPatch)
			},
			{
				58L,
				typeof(EasyDifficultyPowerupPatch)
			},
			{
				59L,
				typeof(IceSpeedTrapPatch)
			}
		};

		internal static readonly Dictionary<long, Region> KeyItemIdToWard = new Dictionary<long, Region>
		{
			{
				50L,
				Region.SVTWard
			},
			{
				51L,
				Region.Train
			},
			{
				52L,
				Region.PhysiotherapyWard
			},
			{
				55L,
				Region.RecordsRoom
			},
			{
				53L,
				Region.Basement
			},
			{
				54L,
				Region.GardenRoom
			}
		};

		internal static readonly long[] RhythmWeightlifterStageToLocationID = new long[12]
		{
			113L, 114L, 115L, 116L, 117L, 118L, 119L, 120L, 121L, 122L,
			180L, 181L
		};

		internal static readonly IReadOnlyCollection<Type> Traps = TrapItemIdToLevel.Values;

		internal static readonly IReadOnlyCollection<Level> Levels = LevelToStage.Keys;

		internal static readonly Dictionary<Level, Act> LevelToAct = LevelToStage.ToDictionary<KeyValuePair<Level, BaseStage>, Level, Act>((KeyValuePair<Level, BaseStage> pair) => pair.Key, (KeyValuePair<Level, BaseStage> pair) => pair.Value.StageAct);

		internal static readonly Dictionary<Region, long> RegionToKeyID = KeyItemIdToWard.ToDictionary((KeyValuePair<long, Region> pair) => pair.Value, (KeyValuePair<long, Region> pair) => pair.Key);

		internal static readonly Dictionary<Act, IEnumerable<Level>> LevelsInAct = (from pair in LevelToStage
			group pair by pair.Value.StageAct).ToDictionary((IGrouping<Act, KeyValuePair<Level, BaseStage>> grouping) => grouping.Key, (IGrouping<Act, KeyValuePair<Level, BaseStage>> grouping) => grouping.Select((KeyValuePair<Level, BaseStage> c) => c.Key));

		internal static readonly Level[] LevelsThatDoNotUnlockBoss = (Level[])(object)new Level[1] { (Level)41 };

		internal static readonly Dictionary<Act, Level[]> ActBoss = new Dictionary<Act, Level[]>
		{
			{
				Act.Act1,
				(Level[])(object)new Level[1] { (Level)6 }
			},
			{
				Act.Act2,
				(Level[])(object)new Level[1] { (Level)16 }
			},
			{
				Act.Act3,
				(Level[])(object)new Level[2]
				{
					(Level)26,
					(Level)84
				}
			},
			{
				Act.Act4,
				(Level[])(object)new Level[1] { (Level)7 }
			},
			{
				Act.Act5,
				(Level[])(object)new Level[1] { (Level)42 }
			},
			{
				Act.Act6,
				(Level[])(object)new Level[1] { (Level)46 }
			},
			{
				Act.Act7,
				(Level[])(object)new Level[2]
				{
					(Level)49,
					(Level)50
				}
			}
		};
	}
	internal enum Region
	{
		MainWard,
		SVTWard,
		Train,
		PhysiotherapyWard,
		RecordsRoom,
		Basement,
		GardenRoom
	}
}
namespace RhythmDoctor.Archipelago.World.Data
{
	internal abstract class BaseStage
	{
		internal Act StageAct { get; init; }

		internal abstract IEnumerable<long> GetLocationsToClear(Rank rank);
	}
	internal class BossStage : BaseStage
	{
		internal long ClearLocation { get; init; }

		internal long? CompletePlusLocation { get; init; }

		internal long PerfectLocation { get; init; }

		internal BossStage(Act act, long clearLocation, long? completePlusLocation, long perfectLocation)
		{
			base.StageAct = act;
			ClearLocation = clearLocation;
			CompletePlusLocation = completePlusLocation;
			PerfectLocation = perfectLocation;
		}

		internal override IEnumerable<long> GetLocationsToClear(Rank rank)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)$"Getting locations to clear for rank {rank.internalValue}");
			List<long> list = new List<long>();
			if (((Rank)(ref rank)).perfected)
			{
				list.Add(PerfectLocation);
			}
			if (CompletePlusLocation.HasValue && (((Rank)(ref rank)).perfected || scnGame.instance.GetPassedLevelWithoutCheckpoints()))
			{
				list.Add(CompletePlusLocation.Value);
			}
			list.Add(ClearLocation);
			return list.AsReadOnly();
		}
	}
	internal class RegularStage : BaseStage
	{
		internal long? BRankLocation { get; init; }

		internal long? ARankLocation { get; init; }

		internal long SRankLocation { get; init; }

		internal RegularStage(Act act, long? bRankLocation, long? aRankLocation, long sRankLocation)
		{
			base.StageAct = act;
			BRankLocation = bRankLocation;
			ARankLocation = aRankLocation;
			SRankLocation = sRankLocation;
		}

		internal override IEnumerable<long> GetLocationsToClear(Rank rank)
		{
			//IL_000a: 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)
			Plugin.Logger.LogDebug((object)$"Getting locations to clear for rank {rank.internalValue}");
			List<long> list = new List<long>();
			switch (Rank.op_Implicit(rank))
			{
			case -15:
			case 5:
			case 15:
				list.Add(SRankLocation);
				goto case -14;
			case -14:
			case 4:
			case 14:
				if (ARankLocation.HasValue)
				{
					list.Add(ARankLocation.Value);
				}
				goto case -13;
			case -13:
			case 3:
			case 13:
				if (BRankLocation.HasValue)
				{
					list.Add(BRankLocation.Value);
				}
				break;
			}
			return list.AsReadOnly();
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches
{
	[HarmonyPatch(typeof(ArmSkin))]
	internal static class LockSleevePaintPatch
	{
		[HarmonyPatch("Load")]
		[HarmonyPrefix]
		private static void LoadDefaultSleevePatch(ref ArmSkin __instance, ref bool __runOriginal)
		{
			//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_0018: 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_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_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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//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_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_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)
			__runOriginal = false;
			int num = Plugin.Random.Next(0, 2);
			RDPlayer player = __instance.player;
			if ((int)player != 0)
			{
				if ((int)player == 1)
				{
					__instance.skinColor = RDConstants.data.skinColors[RDConstants.data.defaultP2SkinColor[num]];
					__instance.sleeveColor = RDConstants.data.sleeveColors[RDConstants.data.defaultP2SleeveColor[num]];
					__instance.nailsColor = RDConstants.data.nailColors[RDConstants.data.defaultP2NailColor[num]];
					__instance.palmLightness = RDConstants.data.defaultP2PalmLightness[num];
					__instance.drawing = RDConstants.data.emptyTexture;
				}
			}
			else
			{
				__instance.skinColor = RDConstants.data.skinColors[RDConstants.data.defaultP1SkinColor[num]];
				__instance.sleeveColor = RDConstants.data.sleeveColors[RDConstants.data.defaultP1SleeveColor[num]];
				__instance.nailsColor = RDConstants.data.nailColors[RDConstants.data.defaultP1NailColor[num]];
				__instance.palmLightness = RDConstants.data.defaultP1PalmLightness[num];
				__instance.drawing = RDConstants.data.emptyTexture;
			}
		}
	}
	[HarmonyPatch(typeof(RDVersionText))]
	internal static class VersionTextPatch
	{
		[HarmonyPatch("SetPage")]
		[HarmonyPostfix]
		private static void AppendClientVersionPatch(RDVersionText __instance)
		{
			Text text = __instance.text;
			string text2 = (text.text += " / Archipelago v0.6.13");
			string text4 = text2;
			__instance.text.text = text4;
		}
	}
	[HarmonyPatch]
	internal static class SavingPatch
	{
		[HarmonyPatch(typeof(PlayerPrefsJson), "Save")]
		[HarmonyPatch(typeof(PlayerPrefsJson), "SaveBackup")]
		[HarmonyPrefix]
		private static void DisableSavingToFilePatch(ref bool __runOriginal, ref PlayerPrefsJson __instance)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			__runOriginal = (int)__instance.fileType == 0;
		}

		[HarmonyPatch(typeof(ArmSkin), "GetDrawingPath")]
		[HarmonyPrefix]
		private unsafe static void RedirectSleevePaintFilePatch(RDPlayer player, ref string __result, ref bool __runOriginal)
		{
			__runOriginal = false;
			__result = Path.Combine(PlayerPrefsJson.GetFileFolderPath(), "scribble" + ((object)(*(RDPlayer*)(&player))/*cast due to .constrained prefix*/).ToString() + "_AP.png");
		}
	}
	[HarmonyPatch]
	internal static class UnapplyPatchesPatch
	{
		[HarmonyPatch(typeof(scnMenu), "Awake")]
		[HarmonyPatch(typeof(scnBase), "GoToMainMenu")]
		[HarmonyPrefix]
		internal static void TearDownClientPluginPatch()
		{
			Plugin.Logger.LogInfo((object)"Tearing down client plugin");
			Plugin.UnapplyGameplayPatches();
			Persistence.Load();
			try
			{
				scnMenu.instance.slots[Configuration.GetSlotToUse()].LoadSlotData();
				Plugin.Logger.LogDebug((object)"Reloaded slot data");
			}
			catch (NullReferenceException)
			{
				Plugin.Logger.LogDebug((object)"Not in main menu, could not load slot data");
			}
			Plugin.Client?.Dispose();
			Plugin.Client = null;
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches.Menu
{
	[HarmonyPatch]
	internal static class ArchipelagoLoginPatch
	{
		[HarmonyPatch(typeof(scnCLS), "Start")]
		[HarmonyPostfix]
		private static void ConstructArchipelagoMenuPatch(scnCLS __instance)
		{
			Plugin.Logger.LogInfo((object)"Renaming custom level ward items");
			Plugin.Logger.LogInfo((object)"Renaming LED sign");
			GameObject.Find("Canvas/Ward Container/LEDSign Container/WardTitle Text").GetComponent<Text>().text = RDString.Get("archipelago.connectScreenTitle");
			Plugin.Logger.LogInfo((object)"Renaming ward options");
			WardOption val = __instance.wardOptions.Find((WardOption wardOption) => (int)wardOption.name == 0);
			WardOption val2 = __instance.wardOptions.Find((WardOption wardOption) => (int)wardOption.name == 1);
			WardOption? obj = __instance.wardOptions.Find((WardOption wardOption) => (int)wardOption.name == 2);
			__instance.ChangeToImportOption();
			if (val != null)
			{
				RectTransform rect = val.rect;
				if (rect != null)
				{
					Transform parent = ((Component)rect).transform.parent;
					if (parent != null)
					{
						((Component)parent).gameObject.SetActive(false);
					}
				}
				__instance.wardOptions.Remove(val);
			}
			if (val2 != null)
			{
				RectTransform rect2 = val2.rect;
				if (rect2 != null)
				{
					Transform parent2 = ((Component)rect2).transform.parent;
					if (parent2 != null)
					{
						((Component)parent2).gameObject.SetActive(false);
					}
				}
				__instance.wardOptions.Remove(val2);
			}
			Plugin.Logger.LogInfo((object)"Renaming Import to Archipelago option");
			Transform obj2 = ((Transform)obj.rect).Find("Button");
			((Component)obj2.Find("Icon Image")).GetComponent<Image>().sprite = AssetHelper.LoadSprite("WardIcons", "Archipelago.png");
			((Component)obj2.Find("Text")).GetComponent<Text>().text = RDString.Get("archipelago.loginButton");
			Plugin.Logger.LogInfo((object)"Disabling DragAndDrop");
			__instance.levelImporter.dragAndDrop.SetActive(false);
			__instance._currentWardOptionIndex = 0;
		}

		[HarmonyPatch(typeof(LevelImporter), "Install")]
		[HarmonyPostfix]
		private static IEnumerator OverrideInstallButtonPatch(IEnumerator result, LevelImporter __instance)
		{
			Plugin.Logger.LogInfo((object)"Locking input");
			((RDBase)__instance).cls.CLSPlaySound("sndImportInstallButtonClick", 1f, "CustomLevelSelect", 1f, 0f);
			__instance.ToggleInsertUrlContainer(false, true, false);
			__instance.CurrentContentName = (ContentName)2;
			__instance.stoppedInstallCoroutine = false;
			__instance.CanToggleClearButton = false;
			__instance.levelsToInstall = new List<ImportLevel>(__instance.toInstallIS.levels);
			foreach (ImportLevel item in __instance.levelsToInstall)
			{
				item.canToggleRemoveButton = false;
			}
			yield return null;
			((Selectable)__instance.stopButton).interactable = false;
			string text = ((Component)((Component)__instance).transform.Find("screen/Contents/InsertURL Container/URL InputField/Text")).GetComponent<Text>().text;
			string[] array = (from text2 in text.Split('\n')
				select text2.Trim()).ToArray();
			Plugin.Logger.LogInfo((object)("Input: '" + GeneralExtensions.Join<string>((IEnumerable<string>)array, (Func<string, string>)null, ", ") + "' (raw: " + Convert.ToBase64String(Encoding.UTF8.GetBytes(text))));
			if (array.Length < 2)
			{
				Plugin.Logger.LogError((object)"URL or Name not input, bailing out");
				__instance.CurrentContentName = (ContentName)3;
				((RDBase)__instance).cls.CLSPlaySound("sndImportInstallFinish", 1f, "CustomLevelSelect", 1f, 0f);
				__instance.AddLevelToErrorSection(__instance.levelsToInstall[0], RDString.Get("archipelago.login.fail.missingInformation"));
				yield break;
			}
			string url = array[0];
			string name = array[1];
			string password = null;
			try
			{
				password = array[2];
			}
			catch (IndexOutOfRangeException)
			{
			}
			Plugin.Logger.LogInfo((object)("URL: " + url + ", Slot Name: " + name));
			if (Utility.IsNullOrWhiteSpace(url) || Utility.IsNullOrWhiteSpace(name))
			{
				Plugin.Logger.LogError((object)"Invalid information, bailing out");
			}
			else
			{
				Plugin.Logger.LogInfo((object)"Creating client");
				Plugin.Client = new RhythmDoctor.Archipelago.Client.Client();
				Task<LoginResult> login = Task.Run(() => Plugin.Client.CreateSessionAndConnect(url, name, password));
				yield return (object)new WaitUntil((Func<bool>)(() => login.IsCompleted));
				if (login.IsCanceled || login.IsFaulted)
				{
					string arg = (login.IsFaulted ? login.Exception.ToString() : "false");
					Plugin.Logger.LogError((object)$"Login has cancelled or faulted (cancel: {login.IsCanceled} / fault: {arg})");
				}
				else
				{
					LoginResult result2 = login.Result;
					if (result2 is LoginSuccessful)
					{
						Plugin.Logger.LogInfo((object)"Logged in!");
						((RDBase)__instance).cls.CLSPlaySound("sndImportInstallFinish", 1f, "CustomLevelSelect", 1f, 0f);
						yield return null;
						UnpatchMenuPatch();
						while (!Plugin.Client.Setup)
						{
							yield return (object)new WaitForSecondsRealtime(1f);
						}
						Plugin.Logger.LogInfo((object)"Heading to Level Select...");
						scnBase.GoToScene("scnLevelSelect");
						yield break;
					}
					LoginFailure val = (LoginFailure)(object)((result2 is LoginFailure) ? result2 : null);
					if (val == null)
					{
						Plugin.Logger.LogWarning((object)"Got to the end of OverrideInstallButtonPatch - this should never happen!");
						yield break;
					}
					Plugin.Logger.LogError((object)("Got LoginFailure: " + string.Join(", ", val.ErrorCodes) + " / " + string.Join(", ", val.Errors)));
				}
				Plugin.Logger.LogError((object)"Login failed (Login)");
				UnapplyPatchesPatch.TearDownClientPluginPatch();
				Plugin.Client?.Dispose();
				Plugin.Client = null;
			}
			__instance.CurrentContentName = (ContentName)3;
			((RDBase)__instance).cls.CLSPlaySound("sndImportInstallFinish", 1f, "CustomLevelSelect", 1f, 0f);
			((Component)((Component)__instance).transform.Find("screen/Contents/Top Panel/Title Text")).GetComponent<Text>().text = RDString.Get("archipelago.login.fail.title");
		}

		[HarmonyPatch(typeof(scnCLS), "Exit")]
		[HarmonyPostfix]
		private static void UnpatchMenuPatch()
		{
			Plugin.UnapplyArchipelagoMenuPatch();
		}

		[HarmonyPatch(typeof(scnCLS), "SelectWardOption")]
		[HarmonyPostfix]
		private static void CustomSelectOptionPatch(ref bool __runOriginal, scnCLS __instance)
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			__runOriginal = false;
			WardOptionName name = __instance.CurrentWardOption.name;
			if ((int)name <= 1)
			{
				Plugin.Logger.LogWarning((object)"Library/Steam Workshop selected in Archipelago login screen");
			}
			else
			{
				__runOriginal = true;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void ArchipelagoImportScreenPatch()
		{
			GameObject gameObject = ((Component)((Component)((Component)scnCLS.instance.levelImporter).gameObject.transform.Find("screen")).gameObject.transform.Find("Contents")).gameObject;
			GameObject gameObject2 = ((Component)gameObject.transform.Find("InsertURL Container")).gameObject;
			GameObject gameObject3 = ((Component)gameObject2.transform.Find("Add Button")).gameObject;
			Text component = ((Component)((Component)gameObject2.transform.Find("URL InputField")).gameObject.transform.Find("Placeholder")).gameObject.GetComponent<Text>();
			Text component2 = ((Component)gameObject2.transform.Find("Instructions")).GetComponent<Text>();
			Text component3 = ((Component)gameObject3.transform.Find("Text")).GetComponent<Text>();
			((UnityEvent)((Component)gameObject.transform.Find("Draggable Content/AddURL Button")).GetComponent<Button>().onClick).Invoke();
			((Component)gameObject.transform.Find("Top Panel/Title Text")).GetComponent<Text>().text = RDString.Get("archipelago.login.menu.title");
			((Component)gameObject2.transform.Find("Cancel Button")).gameObject.SetActive(false);
			component2.text = RDString.Get("archipelago.login.menu.instructions");
			component.text = RDString.Get("archipelago.login.menu.hint");
			component3.text = RDString.Get("archipelago.login.menu.connectButton");
		}

		[HarmonyPatch(typeof(LevelImporter), "ValidateUrl")]
		[HarmonyPrefix]
		private static void StubValidateUrlPatch(ref bool __runOriginal, LevelImporter __instance)
		{
			__runOriginal = false;
			__instance.Install_Public();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void DisableDragAndDropInstallGetPatch(ref bool __result, ref bool __runOriginal)
		{
			__runOriginal = false;
			__result = false;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void DisableDragAndDropInstallSetPatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}
	}
	[HarmonyPatch(typeof(scnMenu))]
	internal static class ArchipelagoMainMenuOptionPatch
	{
		private const string ARCHIPELAGO_OBJECT_NAME = "archipelago";

		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void RenameMusicOptionPatch(scnMenu __instance)
		{
			((Object)((Component)((Component)__instance).transform.Find("mainMenu/options/optionsContainer/music")).gameObject).name = "archipelago";
		}

		[HarmonyPatch("SelectOption")]
		[HarmonyPrefix]
		private static void HandleArchipelagoOptionSelectedPatch(ref bool __runOriginal, scnMenu __instance)
		{
			if (((Object)((Component)__instance.optionsText[__instance.currentOption]).gameObject).name == "archipelago")
			{
				__runOriginal = false;
				Plugin.ApplyArchipelagoMenuPatch();
				__instance.PlayConfirmSound();
				__instance.TransitionToScene("scnCLS");
			}
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches.Gameplay
{
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class Act5Patch
	{
		[HarmonyPatch("PerformEntityAction")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> NicoleBlockageInteractionPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0026: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"GoToAthleteWard", (string)null)
			}).Advance(3).RemoveInstructions(8)
				.SetOpcodeAndAdvance(OpCodes.Ldc_I4_0)
				.InstructionEnumeration();
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void DematerializeNicolePatch(scnLevelSelect __instance)
		{
			((Entity)__instance.nicoleAct5Blockage).visible = false;
		}

		[HarmonyPatch("PrepareAthleteWardTransition")]
		[HarmonyPrefix]
		private static void DoNotShowDreamBubblesPatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}
	}
	[HarmonyPatch]
	internal static class ClearLocationPatch
	{
		private static Dictionary<long, ScoutedItemInfo> ItemsToSend = new Dictionary<long, ScoutedItemInfo>();

		private static long[] JustSentLocations = Array.Empty<long>();

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void ScoutItemsSentPatch(LevelBase __instance)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Invalid comparison between Unknown and I4
			//IL_0081: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)("Scouting locations to send for " + scnGame.internalIdentifier));
			ItemsToSend.Clear();
			JustSentLocations = Array.Empty<long>();
			if (!Enum.TryParse<Level>(scnGame.internalIdentifier, out Level result))
			{
				Plugin.Logger.LogError((object)("Couldn't find Level. Level identifier: " + scnGame.internalIdentifier));
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
				return;
			}
			if ((int)result == 26 && (__instance.dogMode || scnGame.loadDogMode))
			{
				result = (Level)84;
			}
			IEnumerable<long> locationsToClear = Bindings.LevelToStage[result].GetLocationsToClear(Rank.op_Implicit(5));
			((MonoBehaviour)Plugin.Instance).StartCoroutine(ScoutLocationChecks(locationsToClear.ToArray()));
		}

		[HarmonyPatch(typeof(Rankscreen), "ShowAndSaveRank")]
		[HarmonyPrefix]
		private static void CustomClearLocationPatch(bool bossLevelFailed, bool onlySavePersistence, Rankscreen __instance)
		{
			//IL_0000: 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_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)
			Level currentLevel = GetCurrentLevel();
			Rank rankFromMistakes = scnGame.instance.currentLevel.GetRankFromMistakes();
			SendLocations(currentLevel, rankFromMistakes, bossLevelFailed);
		}

		[HarmonyPatch(typeof(Level), "GetRank")]
		[HarmonyPostfix]
		private static void RhythmWeightlifterClearLocationPatch(string __result)
		{
			if (!(__result == "-"))
			{
				Plugin.Client.Session.Locations.CompleteLocationChecks(new long[1] { Bindings.RhythmWeightlifterStageToLocationID[scnRhythmWeightlifter.gameInstance.LevelIndex] });
			}
		}

		[HarmonyPatch(typeof(Rankscreen), "ShowRankDescription")]
		[HarmonyPostfix]
		private static void ShowSentItemsPatch(Rankscreen __instance)
		{
			//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_0059: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemsToSend.Any())
			{
				Plugin.Logger.LogWarning((object)"Couldn't get items sent, possibly due to a network issue.");
				__instance.description.text = "<color=red>" + RDString.Get("archipelago.rankscreen.error") + "</color>";
			}
			else
			{
				Rank rankFromMistakes = scnGame.instance.currentLevel.GetRankFromMistakes();
				IEnumerable<long> stageLocationIDsToClear = GetStageLocationIDsToClear(GetCurrentLevel(), rankFromMistakes);
				long[] array = stageLocationIDsToClear.Where((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id) || JustSentLocations.Contains(id)).ToArray();
				Plugin.Logger.LogDebug((object)("IDs: " + string.Join(", ", stageLocationIDsToClear) + " (of which " + string.Join(", ", array) + " are new)"));
				if (!stageLocationIDsToClear.Any())
				{
					__instance.description.text = RDString.Get("archipelago.rankscreen.nothing");
					return;
				}
				if (array.Length == 0)
				{
					__instance.description.text = RDString.Get("archipelago.rankscreen.nothingNew");
					return;
				}
				__instance.description.text = "";
				__instance.description.fontSize = 10;
				long[] array2 = array;
				foreach (long num2 in array2)
				{
					if (!ItemsToSend.TryGetValue(num2, out ScoutedItemInfo value))
					{
						Plugin.Logger.LogWarning((object)($"Could not get scouted item information for location ID {num2}. " + "This is normal if this ID is tied to a Perfect rank, and Perfect locations are disabled."));
						continue;
					}
					string text = "silver";
					if (((Enum)((ItemInfo)value).Flags).HasFlag((Enum)(object)(ItemFlags)1) || ((Enum)((ItemInfo)value).Flags).HasFlag((Enum)(object)(ItemFlags)2))
					{
						text = "yellow";
					}
					else if (((Enum)((ItemInfo)value).Flags).HasFlag((Enum)(object)(ItemFlags)4))
					{
						text = "red";
					}
					if (value.IsReceiverRelatedToActivePlayer)
					{
						Text description = __instance.description;
						description.text += RDStringExtensions.GetWithSubstitution("archipelago.rankscreen.found", new KeyValuePair<string, string>[1]
						{
							new KeyValuePair<string, string>("item", "<color=" + text + ">" + ((ItemInfo)value).ItemDisplayName + "</color>")
						});
					}
					else
					{
						Text description2 = __instance.description;
						description2.text += RDStringExtensions.GetWithSubstitution("archipelago.rankscreen.sentTo", new KeyValuePair<string, string>[2]
						{
							new KeyValuePair<string, string>("item", "<color=" + text + ">" + ((ItemInfo)value).ItemDisplayName + "</color>"),
							new KeyValuePair<string, string>("player", value.Player.Alias)
						});
					}
				}
			}
			ItemsToSend.Clear();
			JustSentLocations = Array.Empty<long>();
		}

		[HarmonyPatch(typeof(Level_Montage), "SetLevelAsPassed")]
		[HarmonyPostfix]
		private static void MiracleDefibrillatorClearLocationPatch(Level_Montage __instance)
		{
			//IL_0045: 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)
			bool flag = Plugin.Client.TrapManager.IsTrapActive(ScrambleCharactersTrapPatch.name);
			int num = ((!__instance.missedOnce && !((RDClass)__instance).game.GetPassedLevelWithoutCheckpoints()) ? 5 : ((!((RDClass)__instance).game.GetPassedLevelWithoutCheckpoints()) ? 4 : 14));
			IEnumerable<long> enumerable = SendLocations((Level)49, Rank.op_Implicit(num));
			if (!ItemsToSend.Any())
			{
				Plugin.Logger.LogWarning((object)"Couldn't get items sent, possibly due to a network issue.");
				((RDClass)__instance).game.statusText.SetStatusText("Couldn't get items sent.", (Color?)Color.red, 10f, false, true);
			}
			else
			{
				long[] array = enumerable.Where((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id) || JustSentLocations.Contains(id)).ToArray();
				Plugin.Logger.LogDebug((object)("IDs: " + string.Join(", ", enumerable) + " (of which " + string.Join(", ", array) + " are new)"));
				if (!enumerable.Any())
				{
					((RDClass)__instance).game.statusText.SetStatusText(RDString.Get("archipelago.rankscreen.nothing"), (Color?)null, 4f, false, false);
					return;
				}
				if (array.Length == 0)
				{
					((RDClass)__instance).game.statusText.SetStatusText(RDString.Get("archipelago.rankscreen.nothingNew"), (Color?)null, 4f, false, false);
					return;
				}
				IEnumerable<string> values = array.Select((long id) => ((ItemInfo)ItemsToSend[id]).ItemDisplayName);
				((RDClass)__instance).game.statusText.SetStatusText("Found " + string.Join(", ", values), (Color?)null, 10f, false, true);
			}
			if (flag)
			{
				Plugin.Logger.LogInfo((object)"Setting Room 1, Row 2 to Cole");
				((RDClass)__instance).game.rows[1].ent.character.ChangeCharacter((Character)13, (string)null);
			}
		}

		private static IEnumerable<long> SendLocations(Level level, Rank rank, bool bossLevelFailed = false)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//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_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_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_0109: Unknown result type (might be due to invalid IL or missing references)
			if (bossLevelFailed)
			{
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
				return Array.Empty<long>();
			}
			IEnumerable<long> ids = GetStageLocationIDsToClear(level, rank);
			if (Plugin.Client.Slot.endGoal == SlotData.EndGoal.HelpingHands && (int)level == 55 && ((Rank)(ref rank)).passed)
			{
				Plugin.Logger.LogInfo((object)"Setting goal achieved - Helping Hands");
				Plugin.Client.Session.SetGoalAchieved();
			}
			else if (Plugin.Client.Slot.endGoal != SlotData.EndGoal.HelpingHands)
			{
				bool flag = true;
				Rank val = Rank.op_Implicit(Plugin.Client.Slot.endGoal switch
				{
					SlotData.EndGoal.PerfectAll => 5, 
					SlotData.EndGoal.ARankAll => 4, 
					SlotData.EndGoal.BRankAll => 3, 
					_ => throw new ArgumentOutOfRangeException($"End Goal ({Plugin.Client.Slot.endGoal}) not valid value."), 
				});
				foreach (Level level2 in Bindings.Levels)
				{
					Rank levelRank = Persistence.GetLevelRank(level2, false, -1);
					if (Rank.op_Implicit(val) > Rank.op_Implicit(((Rank)(ref levelRank)).ToNormal()))
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					Plugin.Logger.LogInfo((object)"Setting goal achieved - Cleared all");
					Plugin.Client.Session.SetGoalAchieved();
				}
			}
			if (ids.Any((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id)))
			{
				JustSentLocations = ids.Where((long id) => !Plugin.Client.Session.Locations.AllLocationsChecked.Contains(id)).ToArray();
				Task.Run(() => Plugin.Client.Session.Locations.CompleteLocationChecksAsync(ids.ToArray()));
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
			}
			else
			{
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: true);
			}
			return ids;
		}

		private static IEnumerator ScoutLocationChecks(long[] ids, int retries = 0)
		{
			Plugin.Logger.LogInfo((object)string.Format("Scouting location checks for ids {0}... (try {1})", string.Join(", ", ids), retries));
			Task<Dictionary<long, ScoutedItemInfo>> scout = Task.Run(() => Plugin.Client.Session.Locations.ScoutLocationsAsync((HintCreationPolicy)0, ids));
			yield return (object)new WaitUntil((Func<bool>)(() => scout.IsCompleted));
			Plugin.Logger.LogInfo((object)"Completed scouting");
			if (!scout.IsCompletedSuccessfully)
			{
				if (retries >= 3)
				{
					Plugin.Logger.LogError((object)$"Couldn't scout locations - on try #{retries}, retrying");
					((MonoBehaviour)Plugin.Instance).StartCoroutine(ScoutLocationChecks(ids, retries + 1));
				}
				else
				{
					Plugin.Logger.LogError((object)"Couldn't scout locations");
				}
			}
			else
			{
				ItemsToSend = scout.Result;
			}
		}

		private static Level GetCurrentLevel()
		{
			//IL_0065: 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_0060: Invalid comparison between Unknown and I4
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!Enum.TryParse<Level>(scnGame.internalIdentifier, out Level result))
			{
				Plugin.Logger.LogError((object)("Couldn't find Level. Level identifier: " + scnGame.internalIdentifier));
				Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: false);
				throw new ArgumentOutOfRangeException("Couldn't find level " + scnGame.internalIdentifier);
			}
			if (scnGame.instance.currentLevel.dogMode && (int)result == 26)
			{
				return (Level)84;
			}
			return result;
		}

		private static IEnumerable<long> GetStageLocationIDsToClear(Level level, Rank rank)
		{
			//IL_0014: 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_002b: 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)
			Plugin.Logger.LogDebug((object)"Getting locations to clear");
			IEnumerable<long> locationsToClear = Bindings.LevelToStage[level].GetLocationsToClear(rank);
			Plugin.Logger.LogDebug((object)string.Format("Stage to clear: {0} with rank {1} ({2})", level, rank.internalValue, string.Join(", ", locationsToClear)));
			return locationsToClear;
		}
	}
	[HarmonyPatch]
	internal static class DeathLinkPatch
	{
		internal static bool enabled = true;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void ResetDeathLinkPatch()
		{
			Plugin.Logger.LogDebug((object)"Enabling DeathLink patch");
			enabled = true;
		}

		[HarmonyPatch(typeof(RowEntity), "CrackAdvance")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnCrackedHeartPatch(RowEntity __instance)
		{
			if (Plugin.Client.DeathLink != null && enabled && !(__instance.rowMisses < ((RDBase)__instance).game.currentLevel.missesToCrackHeart))
			{
				Plugin.Logger.LogInfo((object)"Sending CrackAdvance death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}

		[HarmonyPatch(typeof(scnGame), "FailLevel")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnLevelFailPatch()
		{
			if (enabled)
			{
				Plugin.Logger.LogInfo((object)"Sending FailLevel death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}

		[HarmonyPatch(typeof(scnGame), "FailLevelLite")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnLevelFailLitePatch(scnGame __instance)
		{
			if (enabled && !(__instance.levelIdentifier == "Montage"))
			{
				Plugin.Logger.LogInfo((object)"Sending FailLevelLite death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}

		[HarmonyPatch(typeof(LevelBase), "RunTag")]
		[HarmonyPostfix]
		private static void SendDeathLinkOnBeansHopperLossPatch(string tag)
		{
			if (enabled && scnGame.internalIdentifier == "BeansHopper" && tag == "miss" && scnGame.instance.currentLevel.i1 < 30)
			{
				Plugin.Logger.LogInfo((object)"Sending Beans Hopper death");
				enabled = false;
				Plugin.Client.SendDeathLink();
			}
		}
	}
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class JanitorPatch
	{
		[HarmonyPatch("PerformEntityAction")]
		[HarmonyPrefix]
		private static void InteractJanitorPatch(scnLevelSelect __instance, ref bool __runOriginal)
		{
			SelectableEntity selectedEntity = __instance.selectedEntity;
			SelectableObject val = (SelectableObject)(object)((selectedEntity is SelectableObject) ? selectedEntity : null);
			if (val == null)
			{
				Plugin.Logger.LogWarning((object)"Current selectable object is null");
			}
			else if (val.action != "talkToJanitor")
			{
				Plugin.Logger.LogDebug((object)"Current selectable object's action is not talkToJanitor");
			}
			else
			{
				Plugin.Logger.LogError((object)"TODO: Implement janitor menu patch");
			}
		}

		[HarmonyPatch("ShowRanksText")]
		[HarmonyPrefix]
		private static void TextJanitorPatch(int index, scnLevelSelect __instance, ref bool __runOriginal)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			SelectableEntity obj = __instance.selectableEntities[index];
			SelectableObject val = (SelectableObject)(object)((obj is SelectableObject) ? obj : null);
			if (val == null)
			{
				Plugin.Logger.LogDebug((object)"Selectable entities is null");
				return;
			}
			if (!((SelectableEntity)val).id.StartsWith("TalkToJanitor"))
			{
				Plugin.Logger.LogDebug((object)"Selected object is not Janitor, doing nothing");
				return;
			}
			Plugin.Logger.LogDebug((object)"Overriding Janitor text");
			__runOriginal = false;
			__instance.ChangeTextOutline(RDConstants.data.levelSelect_notPassedLevelTextOutline);
			__instance.SetDifficultyArrowsVisible(false);
			__instance.description.text = RDString.Get("mainMenu.Archipelago");
		}

		[HarmonyPatch("PlaceJanitor")]
		[HarmonyPrefix]
		private static void PlaceJanitorPatch(ref bool __runOriginal)
		{
			Plugin.Logger.LogDebug((object)"Bypassing PlaceJanitor");
			__runOriginal = false;
		}

		[HarmonyPatch("HideJanitor")]
		[HarmonyPrefix]
		private static void HideJanitorPatch(ref bool __runOriginal)
		{
			Plugin.Logger.LogWarning((object)"Bypassing HideJanitor. This should never be called assuming PlaceJanitor was bypassed!");
			__runOriginal = false;
		}
	}
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class LevelSelectVisualFixesPatch
	{
		private static readonly Level[] ForceDisplayAsRegularLevel;

		private static readonly Level[] ForceDisplayAsBossLevel;

		[HarmonyPatch("ShowRanksText")]
		[HarmonyPrefix]
		private static void ModifyLabelVisibilitiesPatch(int index, scnLevelSelect __instance)
		{
			//IL_001d: 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_0046: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			SelectableEntity obj = __instance.selectableEntities[index];
			SelectableCharacter val = (SelectableCharacter)(object)((obj is SelectableCharacter) ? obj : null);
			if (val != null && val.levels.TryGetValue(__instance.currentDifficulty, out var value))
			{
				if (ForceDisplayAsRegularLevel.Contains(value))
				{
					((SelectableEntity)val).levelType = (LevelType)1;
				}
				else if (ForceDisplayAsBossLevel.Contains(value))
				{
					((SelectableEntity)val).levelType = (LevelType)2;
				}
			}
		}

		[HarmonyPatch("ShowRanksText")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DoNotShowUnlockHintsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0026: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"levelSelect.condition.{0}", (string)null)
			}).SetOpcodeAndAdvance(OpCodes.Nop).SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(scnLevelSelect), "currentDifficulty"), (string)null)
				})
				.Advance(-1)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Nop)
				.SetOpcodeAndAdvance(OpCodes.Br_S)
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"", (string)null)
				})
				.InstructionEnumeration();
		}

		static LevelSelectVisualFixesPatch()
		{
			Level[] array = new Level[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			ForceDisplayAsRegularLevel = (Level[])(object)array;
			ForceDisplayAsBossLevel = (Level[])(object)new Level[1] { (Level)16 };
		}
	}
	[HarmonyPatch]
	internal static class RhythmDogtorLevelPatch
	{
		[HarmonyPatch(typeof(scnLevelSelect), "LoadLevelData")]
		[HarmonyPostfix]
		private static void AddRhythmDogtorPatch(scnLevelSelect __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_00ab: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//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_00e9: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//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)
			Plugin.Logger.LogDebug((object)"Creating Rhythm Dogtor entity");
			SelectableCharacter val = (SelectableCharacter)__instance.FindSelectableEntity("3-X");
			val.bpmHard = val.bpmNormal;
			((SelectableEntity)val).hardEnabled = true;
			val.charactersHard = (Character[])(object)new Character[1] { (Character)22 };
			val.levels[(Difficulty)2] = (Level)84;
			val.portraitsHard = (Character[])(object)new Character[2]
			{
				(Character)23,
				(Character)22
			};
			if (!GC.levelMetadata.ContainsKey((Level)84))
			{
				Plugin.Logger.LogDebug((object)"Creating Rhythm Dogtor metadata");
				LevelMetadata val2 = GC.levelMetadata[(Level)26];
				GuestData guest = new GuestData
				{
					link = val2.guest1.link,
					linkType = val2.guest1.linkType,
					name = val2.guest1.name,
					type = "Mix"
				};
				GuestData guest2 = new GuestData
				{
					link = "https://x.com/Morphious86",
					linkType = "Twitter",
					name = "Morphious86",
					type = "VocalsAndArt"
				};
				LevelMetadata val3 = new LevelMetadata();
				val3.id = "3-DOG";
				val3.type = val2.type;
				val3.portraits = (Character[])(object)new Character[2]
				{
					(Character)23,
					(Character)22
				};
				val3.characters = (Character[])(object)new Character[1] { (Character)22 };
				val3.guest1 = guest;
				val3.guest2 = guest2;
				val3.guest3 = null;
				val3.guest4 = null;
				LevelMetadata value = val3;
				GC.levelMetadata.Add((Level)84, value);
			}
		}

		[HarmonyPatch(typeof(scnLevelSelect), "GoToLevelSequence")]
		[HarmonyPrefix]
		private static void GoToRhythmDogtorPatch(ref string levelToGo, scnLevelSelect __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			if ((int)__instance.currentDifficulty == 2 && (int)RDUtils.ParseEnum<Level>(levelToGo, (Level)0) == 84)
			{
				Plugin.Logger.LogInfo((object)"Going to Rhythm Dogtor...");
				Persistence.SetLastPlayedLevel((Level)84);
				levelToGo = "Lesmis";
				scnGame.loadDogMode = true;
			}
		}

		[HarmonyPatch(typeof(Rankscreen), "ShowAndSaveRank")]
		[HarmonyPrefix]
		private static void SaveRhythmDogtorRankPatch(bool bossLevelFailed, Rankscreen __instance)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!bossLevelFailed && !(((RDBase)__instance).game.levelIdentifier != "Lesmis") && ((RDBase)__instance).game.currentLevel.dogMode)
			{
				Plugin.Logger.LogInfo((object)"Saving Rhythm Dogtor rank...");
				Persistence.SetLevelRank((Level)84, ((RDBase)__instance).game.currentLevel.GetRankFromMistakes(), false, true);
			}
		}

		[HarmonyPatch(typeof(scnLevelSelect), "SetDifficulty")]
		[HarmonyPrefix]
		private static void ShowAdogPatch(Difficulty newDifficulty, scnLevelSelect __instance)
		{
			//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: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			Rank levelRank = Persistence.GetLevelRank((Level)26, false, -1);
			bool passed = ((Rank)(ref levelRank)).passed;
			if ((int)newDifficulty != 1)
			{
				if ((int)newDifficulty == 2)
				{
					__instance.FindSelectableEntity("3-X").gameObject.SetActive(true);
					HideSleepingPaige();
				}
			}
			else if (passed)
			{
				__instance.FindSelectableEntity("3-X").gameObject.SetActive(false);
				HideSleepingPaige();
			}
			void HideSleepingPaige()
			{
				if (((InvisibleEntity)__instance.sleepingPaige).shaderRenderer != null)
				{
					((Entity)__instance.sleepingPaige).visible = false;
				}
				else
				{
					Plugin.Logger.LogWarning((object)"[RhythmDogtorLevelPatch] Sleeping Paige shader renderer is null");
				}
			}
		}
	}
	[HarmonyPatch(typeof(scnRhythmWeightlifter))]
	internal static class RhythmWeightlifterPatch
	{
		[HarmonyPatch("PlayLevelDialogue")]
		[HarmonyPrefix]
		private static void DoNotShowDialoguePatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}
	}
	[HarmonyPatch(typeof(WalkingSelectableCharacter))]
	internal static class RunningCharactersPatch
	{
		[HarmonyPatch("UpdateCharacter")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> WalkingSelectableCharacterOverLockedLevelsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			foreach (CodeInstruction item in val.Instructions())
			{
				if (item.opcode == OpCodes.Call && (MethodInfo)item.operand == AccessTools.Method(typeof(RDUtils), "Locked", new Type[1] { typeof(Level) }, (Type[])null))
				{
					item.opcode = OpCodes.Ldc_I4_0;
				}
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch]
	internal static class SkipCutscenePatch
	{
		[HarmonyPatch(typeof(Persistence), "GetPlayedPassedLevelCutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPostAct2Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPostAct3Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPostAct4Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPreAct5Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPreAct6Cutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedHaileyDuetIntroduction")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedPreBitternessCutscene")]
		[HarmonyPatch(typeof(Persistence), "GetPlayedRooftopCutscene")]
		[HarmonyPrefix]
		private static void PersistenceDoNotPlayCutscenePatch(ref bool __result, ref bool __runOriginal)
		{
			__result = true;
			__runOriginal = false;
		}

		[HarmonyPatch(typeof(scnLevelSelect), "MovePaigeToVendingMachine")]
		[HarmonyPatch(typeof(scnLevelSelect), "PlayAct5Intro")]
		[HarmonyPatch(typeof(scnLevelSelect), "CheckForCutscene")]
		[HarmonyPatch(typeof(scnBase), "GoToCutscene")]
		[HarmonyPrefix]
		private static void LevelSelectDoNotPlayCutscenePatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}

		[HarmonyPatch(typeof(scnLevelSelect), "Start")]
		[HarmonyPostfix]
		private static void SkipStoryAndCutscenePatch(scnLevelSelect __instance)
		{
			scnLevelSelect.bitternessWarningPlayed = true;
			__instance.voidItemProgress = 3;
			__instance.selectableEntities.Find((SelectableEntity entity) => entity.id == "VoidItem1").normalEnabled = true;
			__instance.selectableEntities.Find((SelectableEntity entity) => entity.id == "VoidItem2").normalEnabled = true;
			__instance.selectableEntities.Find((SelectableEntity entity) => entity.id == "VoidItem3").normalEnabled = true;
		}
	}
	[HarmonyPatch(typeof(scnGame))]
	internal static class SkipTutorialPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> FixLesmisPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0026: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"Level_", (string)null)
			}).Advance(3).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldstr, (object)", Assembly-CSharp"),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method("System.String:Concat", new Type[2]
				{
					typeof(string),
					typeof(string)
				}, (Type[])null))
			})
				.InstructionEnumeration();
		}

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		private static void DoNotLoadTutorialPatch()
		{
			if (scnGame.internalIdentifier == "Montage")
			{
				Plugin.Logger.LogDebug((object)"Level is 7-X, not skipping tutorial");
				return;
			}
			Plugin.Logger.LogDebug((object)$"Level {scnGame.internalIdentifier}: Forcing attemptToLoadTutorial from {scnGame.attemptToLoadTutorial} to false");
			scnGame.attemptToLoadTutorial = false;
		}

		[HarmonyPatch(typeof(Persistence), "GetFirstTimePlaying")]
		[HarmonyPrefix]
		private static void DoNotLoadIntroPatch(ref bool __result, ref bool __runOriginal)
		{
			Plugin.Logger.LogDebug((object)"Forcing first_time to false");
			__runOriginal = false;
			__result = false;
		}
	}
	[HarmonyPatch(typeof(Persistence))]
	internal static class StateReplicationPatch
	{
		[HarmonyPatch("SetPaigeEnding")]
		[HarmonyPostfix]
		private static void ReplicatePaigeStaysPatch(bool paigeStays)
		{
			Plugin.Logger.LogInfo((object)string.Format("Replicating {0} to {1}", "paige_stays", paigeStays));
			Plugin.Client.Session.DataStorage[(Scope)3, "paige_stays"] = DataStorageElement.op_Implicit(paigeStays);
		}

		[HarmonyPatch("SetIanDesktopLogin")]
		[HarmonyPostfix]
		private static void ReplicateIansDesktopUnlockedPatch(bool ianDesktopLogin)
		{
			Plugin.Logger.LogInfo((object)string.Format("Replicating {0} to {1}", "ian_desktop_login", ianDesktopLogin));
			Plugin.Client.Session.DataStorage[(Scope)3, "ian_desktop_login"] = DataStorageElement.op_Implicit(ianDesktopLogin);
		}

		internal static async Task InitializeSync()
		{
			Task task = InitializeKey<bool>("paige_stays", Persistence.SetPaigeEnding, delegate
			{
				bool flag = Plugin.Random.Next() % 2 == 1;
				Plugin.Client.Session.DataStorage[(Scope)3, "paige_stays"] = DataStorageElement.op_Implicit(flag);
				return flag;
			});
			Task task2 = InitializeKey<bool>("ian_desktop_login", Persistence.SetIanDesktopLogin, delegate
			{
				Plugin.Client.Session.DataStorage[(Scope)3, "ian_desktop_login"] = DataStorageElement.op_Implicit(false);
				return false;
			});
			Plugin.Logger.LogInfo((object)"Waiting for initialization to complete...");
			await Task.WhenAll(task, task2);
			Plugin.Logger.LogInfo((object)"Initialization completed!");
			static async Task InitializeKey<T>(string key, Action<T> executeExisting, Func<T> valueDoesntExist) where T : notnull
			{
				JToken val = await Plugin.Client.Session.DataStorage[(Scope)3, key].GetAsync();
				if ((int)val.Type != 10 && (int)val.Type != 11)
				{
					T val2 = val.ToObject<T>();
					Plugin.Logger.LogInfo((object)$"Found {key} state: {val2}");
					executeExisting(val2);
				}
				else
				{
					T val3 = valueDoesntExist();
					Plugin.Logger.LogInfo((object)$"Setting initial {key} state to {val3}");
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class TrapManagerPatch
	{
		[HarmonyPatch(typeof(scnLevelSelect), "SelectCharacter")]
		[HarmonyPrefix]
		private static void ApplyApplicableTrapPreviewPatch(scnLevelSelect __instance)
		{
			//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_0021: 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)
			SelectableEntity selectedEntity = __instance.selectedEntity;
			SelectableCharacter val = (SelectableCharacter)(object)((selectedEntity is SelectableCharacter) ? selectedEntity : null);
			if (val != null)
			{
				Level level = val.levels[__instance.currentDifficulty];
				Plugin.Client.TrapManager.ApplyApplicableTraps(level);
			}
		}

		[HarmonyPatch(typeof(HeartMonitor), "Show")]
		[HarmonyPostfix]
		private static void ShowTrapNameOnPhonePatch(HeartMonitor __instance)
		{
			//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_0063: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			IEnumerable<string> previewTrapNames = Plugin.Client.TrapManager.GetPreviewTrapNames();
			if (!previewTrapNames.Any())
			{
				return;
			}
			Plugin.Logger.LogDebug((object)"Instantiating guest credit for preview traps");
			__instance.isGuestCreditShown = true;
			foreach (string item in previewTrapNames)
			{
				Plugin.Logger.LogDebug((object)("Creating guest credit for " + item));
				GuestData val = new GuestData
				{
					type = null,
					link = null,
					linkType = "other-unused",
					name = item
				};
				GameObject val2 = Object.Instantiate<GameObject>(__instance.guestPrefab, (Transform)(object)__instance.creditsContainer);
				HeartMonitorGuest component = val2.GetComponent<HeartMonitorGuest>();
				component.Setup(val);
				__instance.creditStrings.Add(val.name);
				__instance.links.Add(val.link);
				__instance.creditsElements.Add(val2);
				component.nameText.text = item;
			}
		}

		[HarmonyPatch(typeof(scnLevelSelect), "GoToLevelSequence")]
		[HarmonyPostfix]
		private static void ApplyApplicableTrapsPatch(string levelToGo, scnLevelSelect __instance)
		{
			//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_0053: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)"Promoting preview traps to active traps");
			if ((levelToGo == "Lesmis" || levelToGo == "RhythmWeightlifter") ? true : false)
			{
				Plugin.Logger.LogInfo((object)"Going to Rhythm Dogtor/Rhythm Weightlifter (dog) - applying preview traps now");
				Level level = RDUtils.ParseEnum<Level>(levelToGo, (Level)0);
				Plugin.Client.TrapManager.ApplyApplicableTraps(level);
			}
			Plugin.Client.TrapManager.PromotePreviewTrapsToActiveTraps();
		}

		[HarmonyPatch(typeof(scnBase), "GoToLevel")]
		[HarmonyPostfix]
		private static void ApplyApplicableTrapsOnLevelChangePatch(string path)
		{
			//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_000b: Invalid comparison between Unknown and I4
			//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)
			Level val = RDUtils.ParseEnum<Level>(path, (Level)0);
			if ((int)val == 50)
			{
				Plugin.Logger.LogWarning((object)$"Applying traps for {val} immediately");
				Plugin.Client.TrapManager.ApplyApplicableTraps(val);
				Plugin.Client.TrapManager.PromotePreviewTrapsToActiveTraps();
			}
		}

		[HarmonyPatch(typeof(scnGame), "Quit")]
		[HarmonyPostfix]
		private static void RestoreActiveTrapsOnAbandonPatch()
		{
			Plugin.Logger.LogInfo((object)"Clearing active traps (returning to queue)");
			Plugin.Client.TrapManager.ClearActiveTraps(returnToQueue: true);
		}
	}
	[HarmonyPatch(typeof(scnLevelSelect))]
	internal static class UnlockItemPatch
	{
		[HarmonyPatch("LoadLevelData")]
		[HarmonyPostfix]
		private static void UnlockEntitiesWithItemsPatch(scnLevelSelect __instance)
		{
			//IL_00f1: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: 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_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0604: 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_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)"Checking for extra unlocks");
			Plugin.Logger.LogInfo((object)"Checking for regions to unlock");
			bool flag = false;
			foreach (ItemInfo item in Plugin.Client.Session.Items.AllItemsReceived)
			{
				Plugin.Logger.LogDebug((object)$"Processing item {item.ItemName} ({item.ItemId})");
				Level value2;
				if (Bindings.KeyItemIdToWard.TryGetValue(item.ItemId, out var value))
				{
					if (value == Region.Basement)
					{
						flag = true;
					}
					Plugin.Logger.LogInfo((object)$"Unlocking entrance {value}");
					scnLevelSelect.instance.UnlockEntrance(value);
				}
				else if (Bindings.ItemIdToLevel.TryGetValue(item.ItemId, out value2))
				{
					Plugin.Logger.LogInfo((object)string.Format("[{0}] Unlocking stage item {1} ({2}, {3})", "UnlockItemPatch", item.ItemName, item.ItemId, value2));
					Persistence.SetLevelRank(value2, Rank.op_Implicit(-1), false, false);
				}
			}
			if (!flag)
			{
				Plugin.Logger.LogInfo((object)"Locking basement");
				__instance.LockEntrance("GoToBasement");
			}
			Plugin.Logger.LogInfo((object)"Moving 1-CNY");
			__instance.FindSelectableEntity("1-CNY").gamePosition.x = -564f;
			if (Plugin.Client.Slot.endGoal == SlotData.EndGoal.HelpingHands)
			{
				Plugin.Logger.LogInfo((object)"Moving X-1 to the basement");
				SelectableEntity val = __instance.FindSelectableEntity("X-1");
				val.group = 3;
				int index = __instance.selectableEntities.FindIndex((SelectableEntity entity) => ((Object)entity.gameObject).name == "BasementComputer") + 1;
				val.gamePosition = new Vector2(2480f, 53f);
				__instance.selectableEntities.Remove(val);
				__instance.selectableEntities.Insert(index, val);
				if (Bindings.ActBoss.Values.All((Level[] levels) => levels.All(delegate(Level level)
				{
					//IL_0000: 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)
					Rank levelRank2 = Persistence.GetLevelRank(level, false, -1);
					return ((Rank)(ref levelRank2)).passed;
				})))
				{
					Plugin.Logger.LogInfo((object)"Unlocking Art Room and X-0 - Helping Hands");
					__instance.UnlockEntrance(__instance.FindSelectableEntity("GoToArtRoom"));
					Persistence.SetLevelRank((Level)55, Rank.op_Implicit(-1), false, false);
				}
			}
			GameObject.Find("/Scene/Corridor/VendingMachinePaige").gameObject.SetActive(false);
			foreach (SelectableEntity item2 in __instance.selectableEntities.Where((SelectableEntity entity) => entity.id.StartsWith("X-") && !Regex.IsMatch(entity.id, "/[0-9]/")))
			{
				item2.normalEnabled = true;
			}
			__instance.GetSelectableEntity("2-B1").normalEnabled = true;
			__instance.GetSelectableEntity("5-B1").normalEnabled = true;
			foreach (SelectableEntity item3 in __instance.selectableEntities.Where((SelectableEntity entity) => entity.id.StartsWith("3-")))
			{
				item3.normalEnabled = true;
				if (item3.id != "3-X")
				{
					item3.hardEnabled = true;
				}
			}
			foreach (SelectableEntity item4 in __instance.selectableEntities.Where((SelectableEntity entity) => entity.id.StartsWith("5-")))
			{
				item4.normalEnabled = true;
				bool flag2;
				switch (item4.id)
				{
				case "5-1":
				case "5-2":
				case "5-3":
					flag2 = true;
					break;
				default:
					flag2 = false;
					break;
				}
				if (flag2)
				{
					item4.hardEnabled = true;
				}
			}
			GameObject.Find("/Scene/Levels Container/Vertical Movement/5-2").SetActive(true);
			GameObject.Find("/Scene/Levels Container/Vertical Movement/5-3").SetActive(true);
			GameObject.Find("/Scene/Levels Container/Vertical Movement/5-X").SetActive(true);
			SelectableEntity selectableEntity = __instance.GetSelectableEntity("1-CNY");
			selectableEntity.normalEnabled = true;
			selectableEntity.gameObject.SetActive(true);
			SelectableEntity selectableEntity2 = __instance.GetSelectableEntity("1-BOO");
			selectableEntity2.normalEnabled = true;
			selectableEntity2.gameObject.SetActive(true);
			__instance.GetSelectableEntity("MD-1").normalEnabled = true;
			__instance.GetSelectableEntity("1-X").hardEnabled = true;
			SelectableEntity selectableEntity3 = __instance.GetSelectableEntity("2-X");
			selectableEntity3.normalEnabled = true;
			selectableEntity3.hardEnabled = true;
			SelectableEntity selectableEntity4 = __instance.GetSelectableEntity("5-1");
			selectableEntity4.normalEnabled = true;
			selectableEntity4.hardEnabled = true;
			SelectableEntity[] array = (SelectableEntity[])(object)new SelectableEntity[3]
			{
				__instance.FindSelectableEntity("6-2"),
				__instance.FindSelectableEntity("6-X"),
				__instance.FindSelectableEntity("7-1")
			};
			for (int num = 0; num < array.Length; num++)
			{
				array[num].normalEnabled = true;
			}
			GameObject.Find("/Scene/Levels Container/Vertical Movement/6-2").SetActive(true);
			__instance.GetSelectableEntity("VoidItem1").normalEnabled = true;
			__instance.GetSelectableEntity("VoidItem2").normalEnabled = true;
			__instance.GetSelectableEntity("VoidItem3").normalEnabled = true;
			((tk2dBaseSprite)__instance.abandonedWard.voidItems[0]).color = new Color(1f, 1f, 1f, 1f);
			((tk2dBaseSprite)__instance.abandonedWard.voidItems[1]).color = new Color(1f, 1f, 1f, 1f);
			((tk2dBaseSprite)__instance.abandonedWard.voidItems[2]).color = new Color(1f, 1f, 1f, 1f);
			__instance.GetSelectableEntity("7-X").normalEnabled = true;
			Persistence.SetLevelRank((Level)49, Rank.op_Implicit(-1), false, true);
			Rank levelRank = Persistence.GetLevelRank((Level)49, false, -1);
			if (((Rank)(ref levelRank)).passed)
			{
				__instance.GetSelectableEntity("7-X2").normalEnabled = true;
				Persistence.SetLevelRank((Level)50, Rank.op_Implicit(-1), false, true);
			}
			SelectableEntity selectableEntity5 = __instance.GetSelectableEntity("X-0");
			selectableEntity5.normalEnabled = true;
			selectableEntity5.gameObject.SetActive(true);
			SelectableEntity selectableEntity6 = __instance.GetSelectableEntity("X-1");
			selectableEntity6.normalEnabled = true;
			selectableEntity6.gameObject.SetActive(true);
			foreach (Act value3 in Enum.GetValues(typeof(Act)))
			{
				if (!HasUnlockedBossSong(value3))
				{
					continue;
				}
				Plugin.Logger.LogDebug((object)$"Unlocking act {value3}");
				Level[] array2 = Bindings.ActBoss[value3];
				for (int num = 0; num < array2.Length; num++)
				{
					int num2 = (int)array2[num];
					Persistence.SetLevelRank((Level)num2, Rank.op_Implicit(-1), false, false);
					if (num2 == 49)
					{
						__instance.UnlockEntrance(Region.RecordsRoom);
					}
				}
			}
		}

		[HarmonyPatch("LoadLevelData")]
		[HarmonyPatch("LevelJustPassedSequenceCo")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DoNotUnlockEntrancesPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			foreach (CodeInstruction item in val.Instructions())
			{
				if (item.opcode == OpCodes.Call && (MethodInfo)item.operand == AccessTools.Method(typeof(scnLevelSelect), "UnlockEntrance", new Type[1] { typeof(SelectableEntity) }, (Type[])null))
				{
					item.opcode = OpCodes.Nop;
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("UnlockNightShiftLevel")]
		[HarmonyPrefix]
		private static void DoNotUnlockNightShiftLevelPatch(ref bool __runOriginal)
		{
			__runOriginal = false;
		}

		[HarmonyPatch("LoadLevelData")]
		[HarmonyPatch("Awake")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DoNotUnlockLevelsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			List<CodeInstruction> list = val.Instructions();
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val2 = list[i];
				if (!(val2.opcode == OpCodes.Call))
				{
					continue;
				}
				int num;
				if ((MethodInfo)val2.operand == AccessTools.Method(typeof(Persistence), "SetLevelRank", new Type[4]
				{
					typeof(string),
					typeof(Rank),
					typeof(bool),
					typeof(bool)
				}, (Type[])null))
				{
					num = -9;
				}
				else
				{
					if (!((MethodInfo)val2.operand == AccessTools.Method(typeof(Persistence), "SetLevelRank", new Type[4]
					{
						typeof(Level),
						typeof(Rank),
						typeof(bool),
						typeof(bool)
					}, (Type[])null)))
					{
						continue;
					}
					num = -5;
				}
				for (int j = num; j <= 1; j++)
				{
					list[i + j].opcode = OpCodes.Nop;
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("ShowRanksText")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CustomPopulateSelectedVerticalDestinationsPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_000f: 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: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			int match = 0;
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(scnLevelSelect), "selectedVerticalDestinations"), (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher codeMatcher)
			{
				codeMatcher.Advance(1);
				switch (match)
				{
				case 0:
					codeMatcher.Insert((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action>((Action)delegate
					{
						//IL_008a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0094: Expected O, but got Unknown
						//IL_00db: Unknown result type (might be due to invalid IL or missing references)
						//IL_00e5: Expected O, but got Unknown
						Plugin.Logger.LogInfo((object)"Setting Ian's laptop vertical destinations");
						scnLevelSelect.instance.selectedVerticalDestinations = new List<LevelSelectDestination>();
						if (Plugin.Client.Session.Items.AllItemsReceived.Any((ItemInfo item) => item.ItemId == 56))
						{
							Plugin.Logger.LogInfo((object)"Adding sleevePaint");
							scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("sleevePaint", RDString.Get("levelSelect.SleevePaint"), RDString.Get("levelSelect.SleevePaint.details")));
						}
						Plugin.Logger.LogInfo((object)"Adding IanDesktop");
						scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("IanDesktop", RDString.Get("levelSelect.IanDesktop"), RDString.Get($"levelSelect.IanDesktop.details.{((!Persistence.GetIanDesktopLogin()) ? 1 : 2)}")));
					}) });
					break;
				case 1:
					codeMatcher.Insert((CodeInstruction[])(object)new CodeInstruction[1] { Transpilers.EmitDelegate<Action>((Action)delegate
					{
						//IL_008a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0094: Expected O, but got Unknown
						//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
						//IL_00d8: Expected O, but got Unknown
						Plugin.Logger.LogInfo((object)"Setting main elevator vertical destinations");
						scnLevelSelect.instance.selectedVerticalDestinations = new List<LevelSelectDestination>();
						if (Plugin.Client.Session.Items.AllItemsReceived.Any((ItemInfo item) => item.ItemId == Bindings.RegionToKeyID[Region.RecordsRoom]))
						{
							Plugin.Logger.LogInfo((object)"Adding ExitRecordsRoom");
							scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("ExitRecordsRoom", RDString.Get("levelSelect.act6"), RDString.Get("levelSelect.GoToRecordsRoom.day")));
						}
						if (HasUnlockedBossSong(Act.Act7))
						{
							Plugin.Logger.LogInfo((object)"Adding ExitVoid");
							scnLevelSelect.instance.selectedVerticalDestinations.Add(new LevelSelectDestination("ExitVoid", RDString.Get("levelSelect.finale"), RDString.Get("levelSelect.GoToVoid.day")));
						}
					}) });
					break;
				default:
					Plugin.Logger.LogWarning((object)"Matched more than two vertical destinations - plugin may need update!!");
					break;
				}
				match++;
			}, (Action<string>)null).Start()
				.MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldc_I4_S, (object)(sbyte)48, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(RDUtils), "Passed", (Type[])null, (Type[])null), (string)null),
					new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null)
				})
				.ThrowIfInvalid("Couldn't find Level.Bitterness.Passed()")
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Pop, (object)null)
				})
				.SetOpcodeAndAdvance(OpCodes.Br)
				.InstructionEnumeration();
		}

		[HarmonyPatch("UpdateCharacters")]
		[HarmonyPostfix]
		private static void UpdateCharactersPatch(scnLevelSelect __instance)
		{
			//IL_0004: 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_00ae: Invalid comparison between Unknown and I4
			//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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0035: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			if (Rank.op_Implicit(Persistence.GetLevelRank((Level)61, false, -1)) == -2)
			{
				RDShaderProperties val = null;
				switch (__instance.currentWardIndex)
				{
				case 7:
					Plugin.Logger.LogDebug((object)"Applying locked appearance to Rin");
					val = new RDShaderProperties(Color.black, RDConstants.data.levelSelect_lockedLevelTextOutline, 1f, true);
					break;
				case 3:
					Plugin.Logger.LogDebug((object)"Applying unlocked appearance to Rin");
					val = new RDShaderProperties(Color.clear, Color.black, 1f, true);
					break;
				}
				if (val != null)
				{
					((InvisibleEntity)GameObject.Find("/Scene/Corridor/GoToMuseDashRoom/Rin").GetComponent<scrChar>()).shaderData = val;
					val.SetFrameChanged();
				}
			}
			if (Rank.op_Implicit(Persistence.GetLevelRank((Level)41, false, -1)) != -2 && (int)__instance.currentDifficulty != 2)
			{
				__instance.rwCabinetTarp.SetActive(false);
				((Component)__instance.rwCabinet).gameObject.SetActive(true);
				__instance.rwLowpassFilter.cutoffFrequency = 2800f;
			}
		}

		internal static bool HasUnlockedBossSong(Act act)
		{
			//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_0055: 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_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_00d3: Unknown result type (might be due to invalid IL or missing references)
			if (act == Act.None)
			{
				return false;
			}
			Plugin.Logger.LogDebug((object)$"Checking act {act}");
			int num = 0;
			foreach (Level item in Bindings.LevelsInAct[act])
			{
				if (Bindings.LevelsThatDoNotUnlockBoss.Contains(item))
				{
					Plugin.Logger.LogDebug((object)$"Level {item} is marked as does not unlock boss, skipping");
					continue;
				}
				int num2 = Plugin.Client.Slot.bossUnlockRequirement switch
				{
					SlotData.BossUnlockRequirement.ARankAll => 4, 
					SlotData.BossUnlockRequirement.Perfect => 5, 
					SlotData.BossUnlockRequirement.BRankAll => 3, 
					_ => throw new IndexOutOfRangeException("Boss unlock requirement out of valid range"), 
				};
				Plugin.Logger.LogDebug((object)$"Checking level {item}");
				Rank levelRank = Persistence.GetLevelRank(item, false, -1);
				if (Rank.op_Implicit(((Rank)(ref levelRank)).ToNormal()) >= num2)
				{
					num++;
					long bossSongLevelClearRequirement = Plugin.Client.Slot.GetBossSongLevelClearRequirement(act);
					if (num >= bossSongLevelClearRequirement)
					{
						Plugin.Logger.LogInfo((object)$"Unlocking {act} boss ({bossSongLevelClearRequirement} requirement, rank {num2})");
						return true;
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Conditional_Custom))]
	internal static class WelcomeBackPatch
	{
		[HarmonyPatch("Check")]
		[HarmonyPrefix]
		private static void DoNotSkipToBossFightPatch(Conditional_Custom __instance, ref bool __runOriginal, ref bool __result)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			if (Enum.TryParse<Level>(scnGame.internalIdentifier, out Level result) && (int)result == 45)
			{
				__runOriginal = __instance.customExpression != "passedLevel(EdegaRave)";
				if (!__runOriginal)
				{
					Plugin.Logger.LogInfo((object)"Forcing 6-2 to 6-X transition off");
					__result = false;
				}
			}
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches.Gameplay.Traps
{
	internal class ChilliSpeedTrapPatch : ITrap
	{
		[HarmonyPatch(typeof(HeartMonitor))]
		private static class Patch
		{
			[HarmonyPatch("Update")]
			[HarmonyPrefix]
			private static void ForceLevelSpeedPatch(HeartMonitor __instance)
			{
				__instance.isSpeedOptionShown = false;
				__instance.currentLevelSpeedIndex = 2;
				__instance.speedSettings[0].phoneScreen.SetActive(false);
				__instance.speedSettings[1].phoneScreen.SetActive(false);
				__instance.speedSettings[2].phoneScreen.SetActive(true);
				__instance.speedSettingChilli.Play();
			}

			[HarmonyPatch("ChangeLevelSpeed")]
			[HarmonyPrefix]
			private static void DisableChangingLevelSpeedPatch(ref bool __runOriginal)
			{
				Plugin.Logger.LogWarning((object)"Level speed attempted to be changed, ignoring");
				__runOriginal = false;
			}
		}

		private Harmony _harmony;

		public string Name => "Chilli Speed";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlyArray<Type>(new Type[2]
		{
			typeof(ChilliSpeedTrapPatch),
			typeof(IceSpeedTrapPatch)
		});

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.ChilliSpeedTrapPatch");
		}

		public void PreviewLevel()
		{
			_harmony.PatchAll(typeof(Patch));
		}

		public void PreviewLevelEnd()
		{
			_harmony.UnpatchSelf();
		}

		public void Active()
		{
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class FragileHeartTrapPatch : ITrap
	{
		[HarmonyPatch(typeof(MistakesManager))]
		private static class ActivePatch
		{
			[HarmonyPatch("AddMistake")]
			[HarmonyPrefix]
			private static void DoubleMistakeWeightPatch(ref float weight)
			{
				weight *= 2f;
			}
		}

		private Harmony _harmony;

		public string Name => "Fragile Heart";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlySingleElementList<Type>(typeof(StrongHeartPowerupPatch));

		public IEnumerable<Level> IncompatibleWithLevels => LevelExtensions.AllBonusLevels.Concat(LevelExtensions.AllIntermissionLevels).Concat(LevelExtensions.AllBossLevels);

		public bool Compatible(Level _)
		{
			return Plugin.Client.TrapManager.Traps.OfType<FragileHeartTrapPatch>().Count() < 2;
		}

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.FragileHeartTrapPatch");
		}

		public void Active()
		{
			_harmony.PatchAll(typeof(ActivePatch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class GhostTapTrapPatch : ITrap
	{
		private static class ActivePatch
		{
			private static bool _endLevel;

			[HarmonyPatch(typeof(scnGame), "UpdateGameplayInput")]
			[HarmonyPostfix]
			private static void DamageGhostInputPatch(RDPlayer player, bool keyPressed, scnGame __instance)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				if (!_endLevel && keyPressed && __instance.spacebarOnNothing && !(__instance.levelIdentifier == "SongOfTheSea") && !(__instance.levelIdentifier == "SongOfTheSeaH"))
				{
					scrConductor.PlayFeedback((GameSoundType)21, 1f, RDUtils.GetMixerGroup(((int)player == 0) ? "PlayerOneMistakes" : "PlayerTwoMistakes"), 1f, (RDPlayer)(-1), false, false);
					((RDBase)__instance).game.OnMistakeOrHeal(0f, 1f, (Row)null, false, player);
					scnGame.instance.FlashBorderFeedback(false, (Row)null);
				}
			}

			[HarmonyPatch(typeof(Rankscreen), "AdvanceGameover")]
			[HarmonyPostfix]
			private static void DoNotDamageOnExitPatch()
			{
				_endLevel = true;
			}
		}

		private Harmony _harmony;

		public string Name => "Ghost Tap";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlySingleElementList<Type>(typeof(GhostTapTrapPatch));

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.GhostTapTrapPatch");
		}

		public void Active()
		{
			_harmony.PatchAll(typeof(ActivePatch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class HardDifficultyTrapPatch : ITrap
	{
		[HarmonyPatch]
		private static class ActivePatch
		{
			[HarmonyPatch(typeof(Persistence), "GetDefibrillatorP1")]
			[HarmonyPatch(typeof(Persistence), "GetDefibrillatorP2")]
			[HarmonyPrefix]
			private static void ForceHardDifficultyPatch(ref DefibMode __result, ref bool __runOriginal)
			{
				__runOriginal = false;
				__result = (DefibMode)4;
			}

			[HarmonyPatch(typeof(PauseMenu), "Update")]
			[HarmonyPrefix]
			private static void LockDifficultyPatch(ref PauseMenu __instance)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Invalid comparison between Unknown and I4
				//IL_006d: 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_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Invalid comparison between Unknown and I4
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				foreach (var (val3, val4) in __instance.instantiatedModes)
				{
					if ((int)val3 != 4)
					{
						continue;
					}
					foreach (Category category in val4.categories)
					{
						foreach (var (val7, val8) in category.contentArrowsDict)
						{
							if (val7 - 22 <= 1)
							{
								Plugin.Logger.LogDebug((object)$"Setting canChangeContentValue to false for {val7}");
								val8.canChangeContentValue = false;
								if (val8.glitches == null)
								{
									GameObject val9 = Object.Instantiate<GameObject>(val8.glitchesPrefab, ((Component)val8).transform.parent);
									val8.glitches = val9.GetComponentsInChildren<SpriteAnimation>();
								}
							}
						}
					}
				}
			}
		}

		private Harmony _harmony;

		public string Name => "Hard Mode";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlyArray<Type>(new Type[2]
		{
			typeof(EasyDifficultyPowerupPatch),
			typeof(HardDifficultyTrapPatch)
		});

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.EasyDifficultyPowerupPatch");
		}

		public void Active()
		{
			_harmony.PatchAll(typeof(ActivePatch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class IceSpeedTrapPatch : ITrap
	{
		[HarmonyPatch(typeof(HeartMonitor))]
		private static class Patch
		{
			[HarmonyPatch("Update")]
			[HarmonyPrefix]
			private static void ForceLevelSpeed(HeartMonitor __instance)
			{
				__instance.isSpeedOptionShown = false;
				__instance.currentLevelSpeedIndex = 0;
				__instance.speedSettings[0].phoneScreen.SetActive(true);
				__instance.speedSettings[1].phoneScreen.SetActive(false);
				__instance.speedSettings[2].phoneScreen.SetActive(false);
				__instance.speedSettingIce.Play();
			}

			[HarmonyPatch("ChangeLevelSpeed")]
			[HarmonyPrefix]
			private static void DisableChangingLevelSpeedPatch(ref bool __runOriginal)
			{
				Plugin.Logger.LogWarning((object)"Level speed attempted to be changed, ignoring");
				__runOriginal = false;
			}
		}

		private Harmony _harmony;

		public string Name => "Ice Speed";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlyArray<Type>(new Type[2]
		{
			typeof(ChilliSpeedTrapPatch),
			typeof(IceSpeedTrapPatch)
		});

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.IceSpeedTrapPatch");
		}

		public void PreviewLevel()
		{
			_harmony.PatchAll(typeof(Patch));
		}

		public void PreviewLevelEnd()
		{
			_harmony.UnpatchSelf();
		}

		public void Active()
		{
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class ScrambleBeatsoundsTrapPatch : ITrap
	{
		[HarmonyPatch(typeof(LevelBase))]
		private static class Patch
		{
			[HarmonyPatch("DecodeLevelData")]
			[HarmonyPostfix]
			private unsafe static void ModifyCharacterDataPatch(RDLevelData __result)
			{
				//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_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_005b: 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_00c6: 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_00dc: 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_00ef: 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_012d: Unknown result type (might be due to invalid IL or missing references)
				Plugin.Logger.LogDebug((object)"Scramble Beatsounds: Modifying MakeRow and SetBeatSound level events");
				foreach (LevelEvent_MakeRow row in __result.rows)
				{
					SoundEffect val = Enum.Parse<SoundEffect>(row.pulseSound.filename.Replace("snd", "", StringComparison.Ordinal));
					SoundEffect val2 = scrambled[val];
					Plugin.Logger.LogDebug((object)$"MakeRow in rows: {val} -> {val2}");
					row.pulseSound.filename = ((object)(*(SoundEffect*)(&val2))/*cast due to .constrained prefix*/).ToString();
				}
				foreach (LevelEvent_Base levelEvent in __result.levelEvents)
				{
					LevelEvent_SetBeatSound val3 = (LevelEvent_SetBeatSound)(object)((levelEvent is LevelEvent_SetBeatSound) ? levelEvent : null);
					if (val3 != null)
					{
						SoundEffect val4 = Enum.Parse<SoundEffect>(val3.sound.filename);
						SoundEffect val5 = scrambled[val4];
						Plugin.Logger.LogDebug((object)$"SetBeatSound in level events: {val4} -> {val5}");
						val3.sound = new SoundDataStruct(((object)(*(SoundEffect*)(&val5))/*cast due to .constrained prefix*/).ToString().Replace("snd", "", StringComparison.Ordinal), 100, 100, 0, 0, true);
					}
				}
			}
		}

		private Harmony _harmony;

		private static Dictionary<SoundEffect, SoundEffect> scrambled = new Dictionary<SoundEffect, SoundEffect>();

		public string Name => "Scramble Beatsounds";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlySingleElementList<Type>(typeof(ScrambleBeatsoundsTrapPatch));

		public IEnumerable<Level> IncompatibleWithLevels
		{
			get
			{
				Level[] array = new Level[3];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				return new <>z__ReadOnlyArray<Level>((Level[])(object)array);
			}
		}

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.ScrambleBeatsoundsTrapPatch");
		}

		public void Active()
		{
			//IL_0026: 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_002d: Invalid comparison between Unknown and I4
			//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_0060: 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_00aa: 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_00ba: 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)
			SoundEffect[] array = (SoundEffect[])RDEditorConstants.BeatSounds.Clone();
			RandomExtensions.Shuffle(Plugin.Random, array);
			for (int i = 0; i < array.Length; i++)
			{
				SoundEffect key = RDEditorConstants.BeatSounds[i];
				SoundEffect val = array[i];
				if ((int)val == 1)
				{
					int num = Plugin.Random.Next(0, RDEditorConstants.BeatSounds.Length);
					if (num == Array.IndexOf(RDEditorConstants.BeatSounds, (SoundEffect)1))
					{
						num++;
					}
					val = RDEditorConstants.BeatSounds[num];
				}
				scrambled[key] = val;
			}
			Plugin.Logger.LogDebug((object)"Randomized beatsounds:");
			foreach (var (val4, val5) in scrambled)
			{
				Plugin.Logger.LogDebug((object)$"  {val4} -> {val5}");
			}
			_harmony.PatchAll(typeof(Patch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class ScrambleCharactersTrapPatch : ITrap
	{
		[HarmonyPatch]
		private static class ActivePatch
		{
			[HarmonyPatch(typeof(LevelBase), "DecodeLevelData")]
			[HarmonyPostfix]
			private unsafe static void ModifyCharacterDataPatch(RDLevelData __result)
			{
				//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_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_00a8: 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)
				Plugin.Logger.LogDebug((object)"[Scramble Characters] Modifying MakeRow and ChangeCharacter level events");
				foreach (LevelEvent_Base levelEvent in __result.levelEvents)
				{
					LevelEvent_CallCustomMethod val = (LevelEvent_CallCustomMethod)(object)((levelEvent is LevelEvent_CallCustomMethod) ? levelEvent : null);
					if (val != null && val.methodName.StartsWith("ChangeCharacter"))
					{
						Plugin.Logger.LogDebug((object)("[ScrambleCharactersTrapPatch] ChangeCharacter custom method: " + val.methodName));
						string text = val.methodName.Replace("ChangeCharacterSmooth(str:", "", StringComparison.Ordinal).Replace("ChangeCharacter(str:", "", StringComparison.Ordinal).Split(",")[0];
						Character key = Enum.Parse<Character>(text);
						Character val2 = scrambled[key];
						val.methodName = val.methodName.Replace(text, ((object)(*(Character*)(&val2))/*cast due to .constrained prefix*/).ToString(), StringComparison.Ordinal);
						Plugin.Logger.LogDebug((object)string.Format("[{0}] Character changed to: {1}", "ScrambleCharactersTrapPatch", val2));
					}
				}
			}

			[HarmonyPatch(typeof(scnGame), "MakeRow")]
			[HarmonyPrefix]
			private static void ModifyMakeRowPatch(ref Character character)
			{
				//IL_001d: 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_003f: Expected I4, but got Unknown
				Plugin.Logger.LogDebug((object)string.Format("[{0}] Modifying MakeRow method from {1} to {2}", "ScrambleCharactersTrapPatch", character, scrambled[character]));
				character = (Character)(int)scrambled[character];
			}

			[HarmonyPatch(typeof(scrChar), "ChangeCharacter")]
			[HarmonyPrefix]
			private static void ModifyChangeCharacterPatch(ref Character newChar)
			{
				//IL_001d: 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_003f: Expected I4, but got Unknown
				Plugin.Logger.LogDebug((object)string.Format("[{0}] Modifying ChangeCharacter method from {1} to {2}", "ScrambleCharactersTrapPatch", newChar, scrambled[newChar]));
				newChar = (Character)(int)scrambled[newChar];
			}

			[HarmonyPatch(typeof(RDInk), "ParsePortrait")]
			[HarmonyPrefix]
			private static void ModifyInkPortraitPatch(ref string fullName)
			{
				//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_0025: 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)
				string text = fullName.Split("_")[0];
				if (Enum.TryParse<Character>(text, out Character result))
				{
					string text2 = ((object)scrambled[result]/*cast due to .constrained prefix*/).ToString();
					Plugin.Logger.LogDebug((object)$"[Scramble Characters] Modifying portrait from {result} to {text2}");
					fullName = fullName.Replace(text, text2, StringComparison.Ordinal);
				}
			}
		}

		private Harmony _harmony;

		private static Dictionary<Character, Character> scrambled = new Dictionary<Character, Character>();

		public static string name = "Scramble Characters";

		private static readonly IReadOnlyCollection<Character> _disallowedCharacters;

		public string Name => name;

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlySingleElementList<Type>(typeof(ScrambleCharactersTrapPatch));

		public IEnumerable<Level> IncompatibleWithLevels
		{
			get
			{
				Level[] array = new Level[3];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				return new <>z__ReadOnlyArray<Level>((Level[])(object)array);
			}
		}

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.ScrambleCharactersTrapPatch");
		}

		public void Active()
		{
			//IL_0076: 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_009a: 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_008b: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//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_011b: 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_011f: 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_0132: 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)
			Character[] array = (Character[])Enum.GetValues(typeof(Character));
			Character[] array2 = (Character[])array.Clone();
			IReadOnlyList<Character> readOnlyList = array.Where((Character character) => !_disallowedCharacters.Contains(character)).ToList();
			IList<Character> list = ((Character[])readOnlyList.ToArray().Clone()).ToList();
			RandomExtensions.Shuffle(Plugin.Random, array2);
			for (int num = 0; num < array2.Length; num++)
			{
				Character val = array[num];
				if (_disallowedCharacters.Contains(val))
				{
					scrambled[val] = val;
					continue;
				}
				Character value = array2[num];
				if (_disallowedCharacters.Contains(value))
				{
					int index = Plugin.Random.Next(0, list.Count);
					value = readOnlyList[index];
					list.RemoveAt(index);
				}
				scrambled[val] = value;
			}
			Plugin.Logger.LogDebug((object)"[ScrambleCharactersTrapPatch] Randomized characters:");
			foreach (var (val4, val5) in scrambled)
			{
				Plugin.Logger.LogDebug((object)string.Format("[{0}]  {1} -> {2}", "ScrambleCharactersTrapPatch", val4, val5));
			}
			_harmony.PatchAll(typeof(ActivePatch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}

		static ScrambleCharactersTrapPatch()
		{
			Character[] array = new Character[11];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			_disallowedCharacters = new <>z__ReadOnlyArray<Character>((Character[])(object)array);
		}
	}
	internal class ScrambleHitsoundsTrapPatch : ITrap
	{
		[HarmonyPatch(typeof(LevelBase))]
		private static class ActivePatch
		{
			[HarmonyPatch("DecodeLevelData")]
			[HarmonyPostfix]
			private static void ModifyCharacterDataPatch(RDLevelData __result)
			{
				//IL_005c: 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_00ab: 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_00e9: 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_0138: 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_01a8: 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_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)
				Plugin.Logger.LogDebug((object)"[Scramble Hitsounds] Modifying SetClapSounds level events");
				foreach (LevelEvent_Base levelEvent in __result.levelEvents)
				{
					LevelEvent_SetClapSounds val = (LevelEvent_SetClapSounds)(object)((levelEvent is LevelEvent_SetClapSounds) ? levelEvent : null);
					if (val != null)
					{
						Plugin.Logger.LogDebug((object)"[Scramble Hitsounds] SetClapSounds in level events:");
						Plugin.Logger.LogWarning((object)val.p1Sound?.filename);
						if (val.p1Sound.HasValue)
						{
							Plugin.Logger.LogDebug((object)("[Scramble Hitsounds]  P1  " + val.p1Sound.Value.filename + " -> " + scrambled[val.p1Sound.Value.filename]));
							val.p1Sound = new SoundDataStruct(scrambled[val.p1Sound.Value.filename], 100, 100, 0, 0, true);
						}
						if (val.p2Sound.HasValue)
						{
							Plugin.Logger.LogDebug((object)("[Scramble Hitsounds]  P2  " + val.p2Sound.Value.filename + " -> " + scrambled[val.p2Sound.Value.filename]));
							val.p2Sound = new SoundDataStruct(scrambled[val.p2Sound.Value.filename], 100, 100, 0, 0, true);
						}
						if (val.cpuSound.HasValue)
						{
							Plugin.Logger.LogDebug((object)("[Scramble Hitsounds]  CPU " + val.cpuSound.Value.filename + " -> " + scrambled[val.cpuSound.Value.filename]));
							val.cpuSound = new SoundDataStruct(scrambled[val.cpuSound.Value.filename], 100, 100, 0, 0, true);
						}
					}
				}
			}
		}

		private Harmony _harmony;

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

		private static string[] hitsounds = null;

		public string Name => "Scramble Hitsounds";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlySingleElementList<Type>(typeof(ScrambleHitsoundsTrapPatch));

		public IEnumerable<Level> IncompatibleWithLevels
		{
			get
			{
				Level[] array = new Level[4];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				return new <>z__ReadOnlyArray<Level>((Level[])(object)array);
			}
		}

		public void InQueue()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (hitsounds == null)
			{
				hitsounds = LevelEvent_SetClapSounds.GetClapSoundsP1();
			}
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.ScrambleHitsoundsTrapPatch");
		}

		public void Active()
		{
			string[] array = (string[])hitsounds.Clone();
			RandomExtensions.Shuffle(Plugin.Random, array);
			for (int i = 0; i < array.Length; i++)
			{
				scrambled[hitsounds[i]] = array[i];
			}
			Plugin.Logger.LogDebug((object)"[Scramble Hitsounds] Randomized hitsounds:");
			foreach (var (text3, text4) in scrambled)
			{
				Plugin.Logger.LogDebug((object)("[Scramble Hitsounds]  " + text3 + " -> " + text4));
			}
			_harmony.PatchAll(typeof(ActivePatch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
}
namespace RhythmDoctor.Archipelago.Patches.Gameplay.Powerups
{
	internal class EasyDifficultyPowerupPatch : ITrap
	{
		[HarmonyPatch]
		private static class ActivePatch
		{
			[HarmonyPatch(typeof(Persistence), "GetDefibrillatorP1")]
			[HarmonyPatch(typeof(Persistence), "GetDefibrillatorP2")]
			[HarmonyPrefix]
			private static void ForceEasyDifficultyPatch(ref DefibMode __result, ref bool __runOriginal)
			{
				__runOriginal = false;
				__result = (DefibMode)2;
			}

			[HarmonyPatch(typeof(PauseMenu), "Update")]
			[HarmonyPrefix]
			private static void LockDifficultyPatch(ref PauseMenu __instance)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Invalid comparison between Unknown and I4
				//IL_006d: 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_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Invalid comparison between Unknown and I4
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				foreach (var (val3, val4) in __instance.instantiatedModes)
				{
					if ((int)val3 != 4)
					{
						continue;
					}
					foreach (Category category in val4.categories)
					{
						foreach (var (val7, val8) in category.contentArrowsDict)
						{
							if (val7 - 22 <= 1)
							{
								Plugin.Logger.LogDebug((object)$"Setting canChangeContentValue to false for {val7}");
								val8.canChangeContentValue = false;
								if (val8.glitches == null)
								{
									GameObject val9 = Object.Instantiate<GameObject>(val8.glitchesPrefab, ((Component)val8).transform.parent);
									val8.glitches = val9.GetComponentsInChildren<SpriteAnimation>();
								}
							}
						}
					}
				}
			}
		}

		private Harmony _harmony;

		public string Name => "Easy Mode";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlyArray<Type>(new Type[2]
		{
			typeof(EasyDifficultyPowerupPatch),
			typeof(HardDifficultyTrapPatch)
		});

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.EasyDifficultyPowerupPatch");
		}

		public void Active()
		{
			_harmony.PatchAll(typeof(ActivePatch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class StrongHeartPowerupPatch : ITrap
	{
		[HarmonyPatch(typeof(MistakesManager))]
		private static class ActivePatch
		{
			[HarmonyPatch("AddMistake")]
			[HarmonyPrefix]
			private static void HalfMistakeWeightPatch(ref float weight)
			{
				weight /= 2f;
			}
		}

		private Harmony _harmony;

		public string Name => "Strong Heart";

		public IEnumerable<Type> IncompatibleWithTraps => new <>z__ReadOnlySingleElementList<Type>(typeof(FragileHeartTrapPatch));

		public IEnumerable<Level> IncompatibleWithLevels => LevelExtensions.AllBonusLevels.Concat(LevelExtensions.AllIntermissionLevels).Concat(LevelExtensions.AllBossLevels);

		public bool Compatible(Level _)
		{
			return Plugin.Client.TrapManager.Traps.OfType<StrongHeartPowerupPatch>().Count() < 2;
		}

		public void InQueue()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("gg.archipelago.rhythmdoctor.trap.StrongHeartPowerupPatch");
		}

		public void Active()
		{
			_harmony.PatchAll(typeof(ActivePatch));
		}

		public void ActiveEnd()
		{
			_harmony.UnpatchSelf();
		}
	}
}
namespace RhythmDoctor.Archipelago.Interfaces
{
	internal interface ITrap
	{
		internal string Name { get; }

		internal IEnumerable<Type> IncompatibleWithTraps { get; }

		internal IEnumerable<Level> IncompatibleWithLevels => LevelExtensions.AllBonusLevels.Concat(LevelExtensions.AllIntermissionLevels);

		internal bool Compatible(Level level)
		{
			return true;
		}

		internal void InQueue()
		{
		}

		internal void PreviewLevel()
		{
		}

		internal void PreviewLevelEnd()
		{
		}

		internal void Active();

		internal void ActiveEnd();
	}
	internal static class ITrapExtensions
	{
		internal static bool IsIncompatibleWith(this ITrap self, ITrap other, Level level)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return self.IsIncompatibleWith(other.GetType(), level);
		}

		internal static bool IsIncompatibleWith(this ITrap self, Type other, Level level)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!self.IncompatibleWithTraps.Contains(other) && !self.IncompatibleWithLevels.Contains(level))
			{
				return !self.Compatible(level);
			}
			return true;
		}

		internal static bool IsIncompatibleWith(this ITrap self, Level level)
		{
			//IL_0006: 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)
			if (!self.IncompatibleWithLevels.Contains(level))
			{
				return !self.Compatible(level);
			}
			return true;
		}

		internal static bool IsIncompatibleWith(this ITrap self, IEnumerable<ITrap> others, Level level)
		{
			//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)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!others.Any((ITrap otherTrap) => self.IsIncompatibleWith(otherTrap, level)))
			{
				return self.IsIncompatibleWith(level);
			}
			return true;
		}

		internal static bool IsIncompatibleWith(this ITrap self, IEnumerable<(int index, ITrap trap)> others, Level level)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			return self.IsIncompatibleWith(others.Select<(int, ITrap), ITrap>(((int index, ITrap trap) tuple) => tuple.trap), level);
		}
	}
}
namespace RhythmDoctor.Archipelago.Helpers
{
	internal static class AssetHelper
	{
		internal static class AssetType
		{
			internal static class WardIcons
			{
				internal const string TYPE = "WardIcons";

				internal const string ARCHIPELAGO = "Archipelago.png";
			}
		}

		internal static Sprite LoadSprite(string assetType, string assetName)
		{
			return LoadSprite(LoadTexture(assetType, assetName));
		}

		internal static Sprite LoadSprite(Texture2D texture2D)
		{
			//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)
			return Sprite.Create(texture2D, new Rect(0f, 0f, (float)((Texture)texture2D).width, (float)((Texture)texture2D).height), Vector2.zero, 1f);
		}

		internal static Texture2D LoadTexture(string assetType, string assetName)
		{
			//IL_004f: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0064: Expected O, but got Unknown
			string path = Path.Combine(Paths.Assets, assetType, assetName);
			if (!File.Exists(path))
			{
				throw new FileNotFoundException("The asset " + assetType + "/" + assetName + " was not found");
			}
			byte[] array = File.ReadAllBytes(path);
			Texture2D val = new Texture2D(2, 2)
			{
				filterMode = (FilterMode)0
			};
			ImageConversion.LoadImage(val, array);
			return val;
		}
	}
}
namespace RhythmDoctor.Archipelago.Extensions
{
	[HarmonyPatch]
	internal static class scnGameExtensions
	{
		[HarmonyPatch(typeof(scnGame), "FlashBorderFeedback", new Type[]
		{
			typeof(BorderFeedbackType),
			typeof(Row)
		})]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		internal static void FlashBorderFeedbackWithDuration(this scnGame @this, BorderFeedbackType type, float duration, Row rowSource = null)
		{
			Transpiler(null);
			static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_004a: 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_0073: Expected O, but got Unknown
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Expected O, but got Unknown
				return new CodeMatcher((IEnumerable<CodeInstruction>)Transpilers.Manipulator(instructions, (Func<CodeInstruction, bool>)((CodeInstruction item) => item.opcode == OpCodes.Ldarg_2), (Action<CodeInstruction>)delegate(CodeInstruction item)
				{
					item.opcode = OpCodes.Ldarg_3;
				}).ToList(), (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.5f, (string)null)
				}).SetOpcodeAndAdvance(OpCodes.Ldarg_2).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)0.125f, (string)null)
				})
					.SetOpcodeAndAdvance(OpCodes.Ldarg_2)
					.InstructionEnumeration();
			}
		}

		internal static void ShakeAllHearts(this scnGame @this, int jitterCount, int jitterAmount)
		{
			Row[] rows = @this.currentLevel.rows;
			foreach (Row obj in rows)
			{
				if (obj == null)
				{
					continue;
				}
				RowEntity ent = obj.ent;
				if (ent != null)
				{
					scrHeart heart = ent.heart;
					if (heart != null)
					{
						RDUtils.GetOrAddComponent<scrThingShake>(((Component)heart).gameObject).activateThingJitter(jitterCount, jitterAmount);
					}
				}
			}
		}

		internal static void ShakeAllHearts(this scnGame @this, float duration, int amountX, int amountY)
		{
			Row[] rows = @this.currentLevel.rows;
			foreach (Row obj in rows)
			{
				if (obj == null)
				{
					continue;
				}
				RowEntity ent = obj.ent;
				if (ent != null)
				{
					scrHeart heart = ent.heart;
					if (heart != null)
					{
						RDUtils.GetOrAddComponent<scrThingShake>(((Component)heart).gameObject).activateThingJitter(duration, amountX, amountY);
					}
				}
			}
		}

		internal static void ShakeAllHearts(this scnGame @this, float duration, int amount)
		{
			@this.ShakeAllHearts(duration, amount, amount);
		}

		internal static void ShakeAllCharacters(this scnGame @this, int jitterCount, int jitterAmount)
		{
			Row[] rows = @this.currentLevel.rows;
			foreach (Row obj in rows)
			{
				if (obj == null)
				{
					continue;
				}
				RowEntity ent = obj.ent;
				if (ent != null)
				{
					scrChar character = ent.character;
					if (character != null)
					{
						RDUtils.GetOrAddComponent<scrThingShake>(((Component)character).gameObject).activateThingJitter(jitterCount, jitterAmount);
					}
				}
			}
		}

		internal static void ShakeAllCharacters(this scnGame @this, float duration, int amountX, int amountY)
		{
			Row[] rows = @this.currentLevel.rows;
			foreach (Row obj in rows)
			{
				if (obj == null)
				{
					continue;
				}
				RowEntity ent = obj.ent;
				if (ent != null)
				{
					scrChar character = ent.character;
					if (character != null)
					{
						RDUtils.GetOrAddComponent<scrThingShake>(((Component)character).gameObject).activateThingJitter(duration, amountX, amountY);
					}
				}
			}
		}

		internal static void ShakeAllCharacters(this scnGame @this, float duration, int amount)
		{
			@this.ShakeAllCharacters(duration, amount, amount);
		}
	}
	internal static class RandomExtensions
	{
		public static void Shuffle<T>(this Random rng, T[] array)
		{
			int num = array.Length;
			while (num > 1)
			{
				int num2 = rng.Next(num--);
				int num3 = num;
				int num4 = num2;
				T val = array[num2];
				T val2 = array[num];
				array[num3] = val;
				array[num4] = val2;
			}
		}
	}
	internal static class scnLevelSelectExtensions
	{
		internal const int BASEMENT_AREA = 3;

		internal const int MUSE_DASH_AREA = 7;

		internal static void UnlockEntrance(this scnLevelSelect @this, Region regionToUnlock)
		{
			string[] array;
			switch (regionToUnlock)
			{
			case Region.SVTWard:
				array = new string[1] { "GoToSVTWard" };
				break;
			case Region.Train:
				array = new string[1] { "GoToTrain" };
				break;
			case Region.PhysiotherapyWard:
				array = new string[1] { "GoToAthleteWard" };
				break;
			case Region.RecordsRoom:
				array = new string[1] { "MainElevator" };
				break;
			case Region.Basement:
				array = new string[2] { "GoToBasement", "GoToMuseDashRoom" };
				@this.ActivateEntranceRin();
				break;
			case Region.GardenRoom:
				array = new string[1] { "GoToArtRoom" };
				break;
			default:
				Plugin.Logger.LogWarning((object)$"Trying to unlock {regionToUnlock} but it doesn't have an implementation/it is the Main Ward/Records Room");
				return;
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				Plugin.Logger.LogDebug((object)("Unlocking " + text + " entrance"));
				@this.UnlockEntrance(@this.FindSelectableEntity(text));
			}
		}

		internal static void LockEntrance(this scnLevelSelect @this, SelectableEntity entranceToLock)
		{
			entranceToLock.normalEnabled = false;
			entranceToLock.hardEnabled = false;
			switch (entranceToLock.id)
			{
			case "GoToSVTWard":
				@this.mainWard.svtBlockage.SetActive(false);
				break;
			case "GoToAthleteWard":
				@this.mainWard.rooftopBlockade.SetActive(false);
				((Component)@this.nicoleAct5Blockage).gameObject.SetActive(false);
				break;
			case "MainElevator":
				@this.mainWard.SetElevatorOpened(false, 999f);
				break;
			case "GoToBasement":
				GameObject.Find("/Scene/Corridor/RDMainWard/Seamless/Seamless_BasementDoor").SetActive(false);
				break;
			}
		}

		internal static void LockEntrance(this scnLevelSelect @this, string entranceToLock)
		{
			@this.LockEntrance(@this.FindSelectableEntity(entranceToLock));
		}
	}
}
namespace RhythmDoctor.Archipelago.Client
{
	internal sealed class Client : IDisposable
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ErrorReceivedHandler <>9__15_0;

			public static MessageReceivedHandler <>9__15_2;

			public static Func<long, bool> <>9__21_2;

			public static Action <>9__21_1;

			internal void <CreateSession>b__15_0(Exception __exception, string __message)
			{
				Plugin.Logger.LogError((object)string.Format("[{0}] Socket error {1} - {2}", "Client", __exception, __message));
			}

			internal void <CreateSession>b__15_2(LogMessage __message)
			{
				Plugin.Logger.LogInfo((object)string.Format("[{0}] Received message \"{1}\"", "Client", __message));
			}

			internal bool <ProcessItem>b__21_2(long locationId)
			{
				return Bindings.RhythmWeightlifterStageToLocationID.Contains(locationId);
			}

			internal void <ProcessItem>b__21_1()
			{
				Plugin.Logger.LogInfo((object)"[Client] Reloading Sleeve Paint");
				Persistence.p1Skin.Reload();
				Persistence.p2Skin.Reload();
			}
		}

		internal ArchipelagoSession? Session;

		internal DeathLinkService? DeathLink;

		internal SlotData Slot;

		internal readonly TrapManager TrapManager;

		private string _name;

		private string? _password;

		private bool _connected;

		private bool _appliedPatches;

		private int _itemsProcessed;

		private bool _disposed;

		private readonly CancellationTokenSource _cancellationTokenSource;

		private static readonly string[] DeathLinkMessages = new string[13]
		{
			" couldn't defibrillate well enough", " was defeated by Connectifia abortus", " couldn't keep the beat", " had to go back to med school", " lost their ranked match", "'s been waiting for so long", " woof woof woof woof woof woof woof", " is living with regrets", "'s dreams stopped", " played Falcon",
			" couldn't jump over the box of beans", " hit that \"Don't Save Changes\" again", " wishes they could write more, and care less"
		};

		internal bool Setup => _itemsProcessed == 0;

		public Client()
		{
			TrapManager = new TrapManager();
			_cancellationTokenSource = new CancellationTokenSource();
		}

		private ArchipelagoSession CreateSession(string server)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0066: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_00a6: 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_00b1: Expected O, but got Unknown
			Plugin.Logger.LogInfo((object)("Creating Archipelago session to " + server));
			Session = ArchipelagoSessionFactory.CreateSession(server, 38281);
			_connected = true;
			Plugin.Logger.LogDebug((object)"Binding events");
			IArchipelagoSocketHelper socket = Session.Socket;
			object obj = <>c.<>9__15_0;
			if (obj == null)
			{
				ErrorReceivedHandler val = delegate(Exception __exception, string __message)
				{
					Plugin.Logger.LogError((object)string.Format("[{0}] Socket error {1} - {2}", "Client", __exception, __message));
				};
				<>c.<>9__15_0 = val;
				obj = (object)val;
			}
			socket.ErrorReceived += (ErrorReceivedHandler)obj;
			Session.Socket.SocketClosed += (SocketClosedHandler)delegate(string __reason)
			{
				AttemptReconnect(__reason);
			};
			IMessageLogHelper messageLog = Session.MessageLog;
			object obj2 = <>c.<>9__15_2;
			if (obj2 == null)
			{
				MessageReceivedHandler val2 = delegate(LogMessage __message)
				{
					Plugin.Logger.LogInfo((object)string.Format("[{0}] Received message \"{1}\"", "Client", __message));
				};
				<>c.<>9__15_2 = val2;
				obj2 = (object)val2;
			}
			messageLog.OnMessageReceived += (MessageReceivedHandler)obj2;
			Session.Items.ItemReceived += new ItemReceivedHandler(ItemReceived);
			Session.DataStorage[(Scope)3, "paige_stays"].OnValueChanged += new DataStorageUpdatedHandler(ReplicatePaigeStays);
			Session.DataStorage[(Scope)3, "ian_desktop_login"].OnValueChanged += new DataStorageUpdatedHandler(ReplicateIansDesktopUnlocked);
			return Session;
		}

		private async Task AttemptReconnect(string disconnectReason)
		{
			if (_disposed)
			{
				return;
			}
			int tries = 0;
			int maxTries = Configuration.GetAutoReconnectMaxRetries();
			Plugin.Logger.LogWarning((object)("[Client] Disconnected from Archipelago: " + disconnectReason));
			while (true)
			{
				_connected = false;
				if (tries >= maxTries)
				{
					Plugin.Logger.LogFatal((object)(string.Format("[{0}] Reached max retries of {1}. ", "Client", maxTries) + "Considering situation unsalvagable and returning to main menu..."));
					scnBase.GoToMainMenu();
				}
				Plugin.Logger.LogWarning((object)string.Format("[{0}] Attempting to reconnect (try {1}/{2})", "Client", tries, maxTries));
				try
				{
					LoginResult val = await Task.Run(() => Connect(_name, _password), _cancellationTokenSource.Token);
					if (val is LoginSuccessful)
					{
						break;
					}
					if (val is LoginFailure)
					{
						Plugin.Logger.LogError((object)string.Format("[{0}] Failed to reconnect: try {1}/{2}", "Client", tries, maxTries));
					}
					else
					{
						Plugin.Logger.LogError((object)string.Format("[{0}] Failed to reconnect - unknown error: try {1}/{2}", "Client", tries, maxTries));
					}
					goto IL_01f8;
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)string.Format("[{0}] Failed to reconnect - {1}: try {2}/{3}", "Client", ex, tries, maxTries));
					goto IL_01f8;
				}
				IL_01f8:
				tries++;
			}
			_connected = true;
			Plugin.Logger.LogWarning((object)"[Client] Reconnected!");
		}

		private async Task<LoginResult> Connect(string name, string? password = null)
		{
			if (Session == null)
			{
				throw new NullReferenceException("Session is null");
			}
			_name = name;
			_password = password;
			Plugin.Logger.LogInfo((object)"Attempting to connect");
			await Task.Run((Func<Task<RoomInfoPacket>?>)Session.ConnectAsync, _cancellationTokenSource.Token);
			Plugin.Logger.LogInfo((object)"Connected");
			Plugin.Logger.LogInfo((object)"Attempting to login");
			LoginResult loginResult = await Task.Run(() => Session.LoginAsync("Rhythm Doctor", name, (ItemsHandlingFlags)(_appliedPatches ? 1 : 7), new Version("0.6.7"), (string[])null, (string)null, password, true), _cancellationTokenSource.Token);
			Plugin.Logger.LogInfo((object)"Logged in");
			LoginFailure val = (LoginFailure)(object)((loginResult is LoginFailure) ? loginResult : null);
			if (val == null)
			{
				LoginSuccessful loginSuccessful = (LoginSuccessful)(object)((loginResult is LoginSuccessful) ? loginResult : null);
				if (loginSuccessful != null)
				{
					_connected = true;
					Plugin.Logger.LogInfo((object)$"Successfully logged into {loginSuccessful.Slot}/{name} as {Session.ConnectionInfo.Uuid}");
					if (_appliedPatches)
					{
						return loginResult;
					}
					Configuration.DeathLinkConfig deathLinkConfig = await Task.Run((Func<Task<Configuration.DeathLinkConfig>?>)Configuration.GetDeathLink, _cancellationTokenSource.Token);
					Slot = new SlotData(loginSuccessful.SlotData);
					if ((deathLinkConfig == Configuration.DeathLinkConfig.FollowSlot && Slot.deathLink) || deathLinkConfig == Configuration.DeathLinkConfig.On)
					{
						Plugin.Logger.LogInfo((object)"Creating DeathLink");
						DeathLink = DeathLinkProvider.CreateDeathLinkService(Session);
						DeathLink.EnableDeathLink();
						DeathLink.OnDeathLinkReceived += new DeathLinkReceivedHandler(DeathLinkReceived);
					}
					Persistence.currentSlotIndex = Configuration.GetSlotToUse();
					Plugin.ApplyGameplayPatches();
					_appliedPatches = true;
					Persistence.slotPrefs[Configuration.GetSlotToUse()].dict.Clear();
					Persistence.p1Skin.Reload();
					Persistence.p2Skin.Reload();
					foreach (Level value in Enum.GetValues(typeof(Level)))
					{
						Persistence.SetLevelRank(value, Rank.op_Implicit(-2), true, true);
					}
					_connected = true;
					return loginResult;
				}
				string text = "Unknown error: failed to connect to " + name;
				Plugin.Logger.LogError((object)text);
				throw new Exception(text);
			}
			Plugin.Logger.LogError((object)"Login failed (Client)");
			for (int num = 0; num < val.Errors.Length; num++)
			{
				string arg = val.Errors[num];
				ConnectionRefusedError val2 = val.ErrorCodes[num];
				Plugin.Logger.LogError((object)$"Error {val2}: {arg}");
			}
			return loginResult;
		}

		private async Task PrepareSlot()
		{
			if (Session == null)
			{
				throw new NullReferenceException("Session is null");
			}
			await Task.Run((Func<Task?>)StateReplicationPatch.InitializeSync, _cancellationTokenSource.Token);
			foreach (Type trap2 in Bindings.Traps)
			{
				ITrap trap = (ITrap)Activator.CreateInstance(trap2);
				Plugin.Client.Session.DataStorage[(Scope)3, trap.Name].Initialize(JToken.op_Implicit(0));
				Plugin.Client.TrapManager.ClearedTraps.Add(trap.Name, 0);
			}
			Plugin.Client.TrapManager.AddStickyTraps(Plugin.Client.Slot.stickyTraps);
		}

		internal async Task<LoginResult> CreateSessionAndConnect(string server, string name, string? password = null)
		{
			CreateSession(server);
			LoginResult loginResult = await Task.Run(() => Connect(name, password), _cancellationTokenSource.Token);
			if (!loginResult.Successful)
			{
				return loginResult;
			}
			await Task.Run((Func<Task?>)PrepareSlot, _cancellationTokenSource.Token);
			return loginResult;
		}

		private void ItemReceived(ReceivedItemsHelper helper)
		{
			Task.Run(async delegate
			{
				await ProcessItem(helper);
			}, _cancellationTokenSource.Token);
		}

		private async Task ProcessItem(ReceivedItemsHelper helper)
		{
			bool queued = false;
			if (!_connected)
			{
				Plugin.Logger.LogWarning((object)"[Client] Client not connected, waiting...");
				_itemsProcessed++;
				while (!_connected)
				{
					await Task.Delay(1000, _cancellationTokenSource.Token);
				}
				Plugin.Logger.LogWarning((object)"[Client] Client connected, continuing...");
			}
			ItemInfo item = helper.DequeueItem();
			if (!IsReady(item))
			{
				queued = true;
				Plugin.Logger.LogDebug((object)"[Client] Not ready, waiting...");
				while (!IsReady(item))
				{
					await Task.Delay(1000, _cancellationTokenSource.Token);
				}
				Plugin.Logger.LogDebug((object)"[Client] Ready, continuing...");
			}
			if (item.ItemGame != "Rhythm Doctor")
			{
				Plugin.Logger.LogDebug((object)$"Ignoring item {item.ItemName} ({item.ItemId} from {item.ItemGame}), as it is not for our world");
				_itemsProcessed--;
				return;
			}
			if (Bindings.ItemIdToLevel.TryGetValue(item.ItemId, out var value))
			{
				Plugin.Logger.LogInfo((object)string.Format("[{0}] Unlocking stage item {1} ({2}, {3})", "Client", item.ItemName, item.ItemId, value));
				if (queued)
				{
					Plugin.Logger.LogInfo((object)$"Attempting to get rank from locations cleared for {value}");
					if ((int)value == 41)
					{
						int num = Session.Locations.AllLocationsChecked.Count((long locationId) => Bindings.RhythmWeightlifterStageToLocationID.Contains(locationId));
						if (num != 0)
						{
							Plugin.Logger.LogInfo((object)$"Unlocking Rhythm Weightlifter stages up to stage {num}");
							Persistence.SetRhythmWeightlifterLastLevelUnlocked(num);
						}
					}
					else
					{
						BaseStage baseStage = Bindings.LevelToStage[value];
						if (baseStage is RegularStage regularStage)
						{
							if (Session.Locations.AllLocationsChecked.Contains(regularStage.SRankLocation))
							{
								Plugin.Logger.LogInfo((object)"Found S rank location");
								Persistence.SetLevelRank(value, Rank.op_Implicit(5), false, false);
							}
							else if (regularStage.ARankLocation.HasValue && Session.Locations.AllLocationsChecked.Contains(regularStage.ARankLocation.Value))
							{
								Plugin.Logger.LogInfo((object)"Found A rank location");
								Persistence.SetLevelRank(value, Rank.op_Implicit(4), false, false);
							}
							else
							{
								if (!regularStage.BRankLocation.HasValue || !Session.Locations.AllLocationsChecked.Contains(regularStage.BRankLocation.Value))
								{
									Plugin.Logger.LogInfo((object)"Couldn't find any location");
									Persistence.SetLevelRank(value, Rank.op_Implicit(-1), false, false);
									_itemsProcessed--;
									return;
								}
								Plugin.Logger.LogInfo((object)"Found B rank location");
								Persistence.SetLevelRank(value, Rank.op_Implicit(3), false, false);
							}
						}
						else if (baseStage is BossStage bossStage)
						{
							if (Session.Locations.AllLocationsChecked.Contains(bossStage.PerfectLocation))
							{
								Plugin.Logger.LogInfo((object)"Found Perfect rank location");
								Persistence.SetLevelRank(value, Rank.op_Implicit(5), false, false);
							}
							else if (bossStage.CompletePlusLocation.HasValue && Session.Locations.AllLocationsChecked.Contains(bossStage.CompletePlusLocation.Value))
							{
								Plugin.Logger.LogInfo((object)"Found Complete+ rank location");
								Persistence.SetLevelRank(value, Rank.op_Implicit(14), false, false);
							}
							else
							{
								if (!Session.Locations.AllLocationsChecked.Contains(bossStage.ClearLocation))
								{
									Plugin.Logger.LogInfo((object)"Couldn't find any location");
									Persistence.SetLevelRank(value, Rank.op_Implicit(-1), false, false);
									_itemsProcessed--;
									return;
								}
								Plugin.Logger.LogInfo((object)"Found Clear rank location");
								Persistence.SetLevelRank(value, Rank.op_Implicit(4), false, false);
							}
						}
						Plugin.Logger.LogInfo((object)"Checking if boss song unlocked");
						Act act = Bindings.LevelToAct[value];
						if (UnlockItemPatch.HasUnlockedBossSong(act))
						{
							Level[] array = Bindings.ActBoss[act];
							if (act == Act.Act7)
							{
								scnLevelSelect.instance?.UnlockEntrance(Region.RecordsRoom);
							}
							Level[] array2 = array;
							foreach (Level val in array2)
							{
								Plugin.Logger.LogInfo((object)$"Attempting to get boss rank from locations cleared for {array}");
								BossStage bossStage2 = (BossStage)Bindings.LevelToStage[val];
								if (Session.Locations.AllLocationsChecked.Contains(bossStage2.PerfectLocation))
								{
									Plugin.Logger.LogInfo((object)"Found Perfect location");
									Persistence.SetLevelRank(val, Rank.op_Implicit(5), false, false);
								}
								else if (bossStage2.CompletePlusLocation.HasValue && Session.Locations.AllLocationsChecked.Contains(bossStage2.CompletePlusLocation.Value))
								{
									Plugin.Logger.LogInfo((object)"Found Complete+ location");
									Persistence.SetLevelRank(val, Rank.op_Implicit(14), false, false);
								}
								else if (Session.Locations.AllLocationsChecked.Contains(bossStage2.ClearLocation))
								{
									Plugin.Logger.LogInfo((object)"Found Clear location");
									Persistence.SetLevelRank(val, Rank.op_Implicit(4), false, false);
								}
								else
								{
									Plugin.Logger.LogInfo((object)"Couldn't find any location");
									Persistence.SetLevelRank(val, Rank.op_Implicit(-1), false, false);
								}
							}
						}
					}
				}
				else
				{
					Persistence.SetLevelRank(value, Rank.op_Implicit(-1), false, false);
				}
				_itemsProcessed--;
				return;
			}
			if (Bindings.TrapItemIdToLevel.TryGetValue(item.ItemId, out Type value2))
			{
				Plugin.Logger.LogInfo((object)$"Adding trap item {item.ItemName} ({item.ItemId})");
				await TrapManager.AddTrap(value2);
				_itemsProcessed--;
				return;
			}
			if (Bindings.KeyItemIdToWard.TryGetValue(item.ItemId, out var value3))
			{
				if (!(scnBase.instance is scnLevelSelect))
				{
					Plugin.Logger.LogInfo((object)"Got region key, but not in level select so ignoring");
					_itemsProcessed--;
					return;
				}
				Plugin.Logger.LogInfo((object)$"Unlocking entrance {value3}");
				scnLevelSelect.instance.UnlockEntrance(value3);
			}
			else if (56 == item.ItemId)
			{
				Harmony.UnpatchID("gg.archipelago.rhythmdoctor.sleevepaint");
				Plugin.Logger.LogDebug((object)"Queueing reloading Sleeve Paint on main thread");
				Plugin.ToExecuteOnMainThread.Enqueue(delegate
				{
					Plugin.Logger.LogInfo((object)"[Client] Reloading Sleeve Paint");
					Persistence.p1Skin.Reload();
					Persistence.p2Skin.Reload();
				});
				_itemsProcessed--;
				return;
			}
			Plugin.Logger.LogError((object)$"Got item {item.ItemName} ({item.ItemId} from {item.ItemGame}) but couldn't handle it");
			_itemsProcessed--;
			bool IsReady(ItemInfo val2)
			{
				if (scnBase.instance is scnCLS)
				{
					return false;
				}
				if (_appliedPatches)
				{
					return true;
				}
				if (Enumerable.Contains(Bindings.TrapItemIdToLevel.Keys, val2.ItemId))
				{
					return true;
				}
				return false;
			}
		}

		private void DeathLinkReceived(DeathLink deathLink)
		{
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Invalid comparison between Unknown and I4
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)$"DeathLink from {deathLink.Source} by \"{deathLink.Cause}\" at {deathLink.Timestamp}");
			if (!DeathLinkPatch.enabled)
			{
				return;
			}
			string text = (string.IsNullOrWhiteSpace(deathLink.Cause) ? (deathLink.Source + " died") : deathLink.Cause);
			if (scnGame.instance != null)
			{
				if (scnGame.instance.levelIdentifier == "BeansHopper")
				{
					Plugin.Logger.LogInfo((object)"Running tag 'miss'");
					DeathLinkPatch.enabled = false;
					scnGame.instance.currentLevel.RunTag("miss");
					return;
				}
				Plugin.Logger.LogInfo((object)"Breaking all hearts");
				scrConductor.PlayFeedback((GameSoundType)21, 1f, RDUtils.GetMixerGroup("MistakesParent"), 1f, (RDPlayer)(-1), false, false);
				scnGame.instance.FlashBorderFeedbackWithDuration((BorderFeedbackType)1, 5f);
				scnGame.instance.ShakeAllHearts(1f, 8);
				scnGame.instance.ShakeAllCharacters(1f, 8);
				scnGame.instance.currentLevel.CrackAllHearts();
				MistakesManager mistakesManager = scnGame.instance.mistakesManager;
				mistakesManager.mistakesCountP1 += 500f;
				MistakesManager mistakesManager2 = scnGame.instance.mistakesManager;
				mistakesManager2.mistakesCountP2 += 500f;
				DeathLinkPatch.enabled = false;
				if (scnGame.instance.currentLevel.shouldMakeHealthBar)
				{
					scnGame.instance.UpdatePlayerHealthBars();
					if (!scnGame.instance.currentLevel.noBossFail)
					{
						scnGame.instance.FailLevel(scnGame.instance.rows[0].ent);
					}
				}
				scnGame.instance.statusText.SetStatusText(text, (Color?)Color.red, 10f, true, true);
				return;
			}
			scnBase instance = scnBase.instance;
			scnIanDesktop val = (scnIanDesktop)(object)((instance is scnIanDesktop) ? instance : null);
			if (val != null && (int)val.state == 1)
			{
				switch (val.currentProgramIndex)
				{
				case 0:
					Plugin.Logger.LogInfo((object)"Killing stacker");
					val.stackerManager.gameoverContainer.SetActive(true);
					val.stackerManager.hasLost = true;
					val.stackerManager.hiScoreText.text = RDString.Get("rhythmStacker.hiScore").Replace("[score]", val.stackerManager.highestScore.ToString(), StringComparison.Ordinal);
					RDStringToUIText.Apply(val.stackerManager.hiScoreText, true, false, 0f);
					val.stackerManager.hiScoreText.text = text + "\n" + val.stackerManager.hiScoreText.text;
					val.stackerManager.PlaySound("sndDesktopJingleNeutral", 1f, 1f);
					break;
				case 1:
					Plugin.Logger.LogInfo((object)"Killing tempres");
					val.tempresManager.currentGameHasFinished = true;
					break;
				}
			}
		}

		private void ReplicatePaigeStays(JToken oldValue, JToken newValue, Dictionary<string, JToken> _)
		{
			Plugin.Logger.LogInfo((object)$"[Replication] Paige stays {oldValue}->{newValue}");
			Persistence.SetPaigeEnding(newValue.ToObject<bool>());
		}

		private void ReplicateIansDesktopUnlocked(JToken oldValue, JToken newValue, Dictionary<string, JToken> _)
		{
			Plugin.Logger.LogInfo((object)$"[Replication] Ian's desktop unlocked {oldValue}->{newValue}");
			Persistence.SetIanDesktopLogin(newValue.ToObject<bool>());
		}

		internal void SendDeathLink()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			PlayerInfo activePlayer = Session.Players.ActivePlayer;
			string text = activePlayer.Alias + DeathLinkMessages[Plugin.Random.Next(DeathLinkMessages.Length)];
			DeathLink deathLink = new DeathLink(activePlayer.Alias, text);
			SendDeathLink(deathLink);
		}

		private void SendDeathLink(DeathLink deathLink)
		{
			DeathLinkService? deathLink2 = Plugin.Client.DeathLink;
			if (deathLink2 != null)
			{
				deathLink2.SendDeathLink(deathLink);
			}
			Plugin.Logger.LogInfo((object)("Sent death link: \"" + deathLink.Cause + "\""));
		}

		public void Dispose()
		{
			_disposed = true;
			_cancellationTokenSource.Cancel();
			_cancellationTokenSource.Dispose();
			if (Session != null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(DisconnectSession(Session));
			}
			TrapManager.Dispose();
			static IEnumerator DisconnectSession(ArchipelagoSession __session)
			{
				Plugin.Logger.LogInfo((object)"Disconnecting session...");
				Task disconnect = Task.Run((Func<Task?>)__session.Socket.DisconnectAsync);
				yield return (object)new WaitUntil((Func<bool>)(() => disconnect.IsCompleted));
			}
		}
	}
	internal readonly struct SlotData
	{
		internal enum EndGoal
		{
			HelpingHands,
			BRankAll,
			ARankAll,
			PerfectAll
		}

		internal enum BossUnlockRequirement
		{
			BRankAll,
			ARankAll,
			Perfect
		}

		internal readonly EndGoal endGoal;

		internal readonly BossUnlockRequirement bossUnlockRequirement;

		internal readonly long act1BossUnlockRequirement;

		internal readonly long act2BossUnlockRequirement;

		internal readonly long act3BossUnlockRequirement;

		internal readonly long act4BossUnlockRequirement;

		internal readonly long act5BossUnlockRequirement;

		internal readonly long act6BossUnlockRequirement;

		internal readonly long act7BossUnlockRequirement;

		internal readonly string[] stickyTraps;

		internal readonly bool perfectRankLocations;

		internal readonly bool deathLink;

		internal SlotData(Dictionary<string, object> slotData)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			string text = "Creating SlotData from";
			foreach (KeyValuePair<string, object> slotDatum in slotData)
			{
				slotDatum.Deconstruct(out var key, out var value);
				string arg = key;
				object obj = value;
				text += $" key: {arg}, value: {obj} (type {obj.GetType().Name})";
			}
			Plugin.Logger.LogDebug((object)text);
			endGoal = (EndGoal)(long)slotData["end_goal"];
			bossUnlockRequirement = (BossUnlockRequirement)(long)slotData["boss_unlock_requirement"];
			act1BossUnlockRequirement = (long)slotData["act_1_boss_unlock_requirement"];
			act2BossUnlockRequirement = (long)slotData["act_2_boss_unlock_requirement"];
			act3BossUnlockRequirement = (long)slotData["act_3_boss_unlock_requirement"];
			act4BossUnlockRequirement = (long)slotData["act_4_boss_unlock_requirement"];
			act5BossUnlockRequirement = (long)slotData["act_5_boss_unlock_requirement"];
			act6BossUnlockRequirement = (long)slotData["act_6_boss_unlock_requirement"];
			act7BossUnlockRequirement = (long)slotData["act_7_boss_unlock_requirement"];
			stickyTraps = ((JToken)(JArray)slotData["sticky_traps"]).ToObject<List<string>>().ToArray();
			deathLink = (long)slotData["death_link"] != 0;
			perfectRankLocations = (long)slotData["perfect_rank_locations"] != 0;
			Plugin.Logger.LogDebug((object)$"Created SlotData - End Goal {endGoal}, Boss Unlock Requirement {bossUnlockRequirement}, [{act1BossUnlockRequirement}, {act2BossUnlockRequirement}, {act3BossUnlockRequirement}, {act4BossUnlockRequirement}, {act5BossUnlockRequirement}, {act6BossUnlockRequirement}, {act7BossUnlockRequirement}] Death Link {deathLink}, Perfect Rank Locations {perfectRankLocations}");
		}

		internal long GetBossSongLevelClearRequirement(Act act)
		{
			return act switch
			{
				Act.Act1 => act1BossUnlockRequirement, 
				Act.Act2 => act2BossUnlockRequirement, 
				Act.Act3 => act3BossUnlockRequirement, 
				Act.Act4 => act4BossUnlockRequirement, 
				Act.Act5 => act5BossUnlockRequirement, 
				Act.Act6 => act6BossUnlockRequirement, 
				Act.Act7 => act7BossUnlockRequirement, 
				_ => throw new ArgumentOutOfRangeException("act", act, null), 
			};
		}
	}
	internal sealed class TrapManager : IDisposable
	{
		private readonly Dictionary<string, int> _remoteTrapClearCache = new Dictionary<string, int>();

		private (int index, ITrap trap)[] _previewTraps = Array.Empty<(int, ITrap)>();

		private (int index, ITrap trap)[] _activeTraps = Array.Empty<(int, ITrap)>();

		internal readonly List<ITrap> Traps = new List<ITrap>();

		internal readonly List<ITrap> StickyTraps = new List<ITrap>();

		internal readonly Dictionary<string, int> ClearedTraps;

		private readonly SemaphoreSlim _gettingTrapClearedSemaphore;

		public TrapManager(Dictionary<string, int>? clearedTraps = null)
		{
			Events.Instance.LevelDeselected += OnLevelDeselected;
			ClearedTraps = clearedTraps ?? new Dictionary<string, int>();
			_gettingTrapClearedSemaphore = new SemaphoreSlim(1, 1);
		}

		internal async Task AddTrap(Type type)
		{
			Plugin.Logger.LogInfo((object)("[TrapManager] Creating " + type.Name + " trap from type"));
			await AddTrap((ITrap)Activator.CreateInstance(type));
		}

		internal async Task AddTrap(ITrap trap, bool doNotCheckPriorClear = false)
		{
			if (await CheckIfTrapAlreadyCleared(trap.Name))
			{
				Plugin.Logger.LogInfo((object)("[TrapManager] Skipping " + trap.Name + " trap as it has been cleared previously"));
				ClearedTraps[trap.Name]++;
			}
			else
			{
				Plugin.Logger.LogInfo((object)("[TrapManager] Adding " + trap.Name + " trap as we haven't cleared it yet"));
				Traps.Add(trap);
				trap.InQueue();
			}
			async Task<bool> CheckIfTrapAlreadyCleared(string trapName)
			{
				if (doNotCheckPriorClear)
				{
					return false;
				}
				Plugin.Logger.LogInfo((object)("[TrapManager] Checking if " + trapName + " has been cleared previously..."));
				int local = ClearedTraps[trapName];
				_remoteTrapClearCache.TryGetValue(trapName, out var remoteCache);
				if (remoteCache != 0 && local <= remoteCache)
				{
					Plugin.Logger.LogDebug((object)string.Format("[{0}] {1} already cleared: l:{2} <= c:{3} && c != 0", "TrapManager", trapName, local, _remoteTrapClearCache[trapName]));
					return true;
				}
				Plugin.Logger.LogInfo((object)("[TrapManager] Waiting for semaphore to check DataStorage for " + trapName + "..."));
				await _gettingTrapClearedSemaphore.WaitAsync();
				try
				{
					Plugin.Logger.LogInfo((object)("[TrapManager] Got semaphore, checking DataStorage for " + trapName + "..."));
					Task<int> getTrapClearsRemote = Plugin.Client.Session.DataStorage[(Scope)3, trapName].GetAsync<int>();
					if (await Task.WhenAny(new Task[2]
					{
						getTrapClearsRemote,
						Task.Delay(Configuration.GetRemoteTrapClearsTimeout())
					}) == getTrapClearsRemote)
					{
						await getTrapClearsRemote;
						remoteCache = await getTrapClearsRemote;
					}
					else
					{
						Plugin.Logger.LogError((object)("[TrapManager] Getting " + trapName + " clear status timed out " + $"({Configuration.GetRemoteTrapClearsTimeout()}ms) - " + $"setting {remoteCache} to last known good value or 0."));
						remoteCache = Math.Max(0, remoteCache);
					}
					if (remoteCache != 0 && local <= remoteCache)
					{
						_remoteTrapClearCache[trapName] = remoteCache;
						Plugin.Logger.LogDebug((object)string.Format("[{0}] {1} already cleared: l:{2} <= r:{3} != 0 (updated cache)", "TrapManager", trapName, local, remoteCache));
						return true;
					}
					Plugin.Logger.LogInfo((object)string.Format("[{0}] {1} not cleared: l:{2} <= r:{3} != 0 (updated cache)", "TrapManager", trapName, local, remoteCache));
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)ex);
				}
				finally
				{
					Plugin.Logger.LogDebug((object)("[TrapManager] Releasing semaphore (used for " + trapName + ")"));
					_gettingTrapClearedSemaphore.Release();
				}
				Plugin.Logger.LogDebug((object)string.Format("[{0}] {1} not cleared: l:{2} <= r:{3} != 0", "TrapManager", trapName, local, remoteCache));
				return false;
			}
		}

		internal void AddStickyTraps(params string[] traps)
		{
			foreach (string text in traps)
			{
				Plugin.Logger.LogDebug((object)("[TrapManager] Adding sticky trap " + text));
				ITrap trap = GetTrapFromName(text);
				trap.InQueue();
				StickyTraps.Add(trap);
			}
			static ITrap GetTrapFromName(string name)
			{
				return name switch
				{
					"Scramble Characters" => new ScrambleCharactersTrapPatch(), 
					"Scramble Beatsounds" => new ScrambleBeatsoundsTrapPatch(), 
					"Scramble Hitsounds" => new ScrambleHitsoundsTrapPatch(), 
					"Ghost Tap" => new GhostTapTrapPatch(), 
					_ => throw new NotImplementedException(), 
				};
			}
		}

		internal bool IsTrapActive(string trapName)
		{
			(int, ITrap)[] activeTraps = Plugin.Client.TrapManager._activeTraps;
			for (int i = 0; i < activeTraps.Length; i++)
			{
				if (activeTraps[i].Item2.Name == trapName)
				{
					return true;
				}
			}
			return false;
		}

		private void ClearTrapsList(ref (int index, ITrap trap)[] trapList, bool returnToQueue)
		{
			Plugin.Logger.LogInfo((object)string.Format("[{0}] Clearing traps list (return to queue: {1})", "TrapManager", returnToQueue));
			if (returnToQueue)
			{
				Plugin.Logger.LogInfo((object)string.Format("[{0}] Restoring {1} traps back into the trap queue", "TrapManager", trapList.Length));
				(int, ITrap)[] array = trapList;
				for (int i = 0; i < array.Length; i++)
				{
					var (num, trap) = array[i];
					if (num == -1)
					{
						Plugin.Logger.LogDebug((object)("[TrapManager] Trap " + trap.Name + " is sticky, not returning."));
					}
					else
					{
						Traps.Insert(num, trap);
					}
				}
			}
			trapList = Array.Empty<(int, ITrap)>();
		}

		private (int index, ITrap trap)[] PopApplicableTraps(Level level)
		{
			//IL_000f: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogDebug((object)string.Format("[{0}] Getting applicable traps for level {1}", "TrapManager", level));
			List<(int, ITrap)> list = new List<(int, ITrap)>();
			foreach (ITrap stickyTrap in StickyTraps)
			{
				Plugin.Logger.LogDebug((object)("[TrapManager] Checking sticky trap " + stickyTrap.Name));
				if (!stickyTrap.IsIncompatibleWith(list, level))
				{
					Plugin.Logger.LogDebug((object)("[TrapManager] Adding sticky trap " + stickyTrap.Name));
					list.Add((-1, stickyTrap));
				}
			}
			for (int i = 0; i < Traps.Count; i++)
			{
				ITrap trap = Traps[i];
				Plugin.Logger.LogDebug((object)string.Format("[{0}] Checking trap {1} at position {2}/{3}", "TrapManager", trap.Name, i, Traps.Count));
				if (!trap.IsIncompatibleWith(list, level))
				{
					Plugin.Logger.LogDebug((object)string.Format("[{0}] Adding trap {1} with original position {2}", "TrapManager", trap.Name, i));
					list.Add((i, trap));
				}
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				int item = list[num].Item1;
				if (item == -1)
				{
					Plugin.Logger.LogDebug((object)"Not removing sticky trap from main queue");
				}
				else
				{
					Plugin.Logger.LogDebug((object)$"{num}: Removing trap from main queue at {item}");
					Traps.RemoveAt(item);
				}
			}
			_previewTraps = list.ToArray();
			return _previewTraps;
		}

		internal (int index, ITrap trap)[] ApplyApplicableTraps(Level level)
		{
			//IL_000a: 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_0090: 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)
			Plugin.Logger.LogInfo((object)$"Applying applicable traps for {level}");
			if (_previewTraps.Length != 0)
			{
				Plugin.Logger.LogWarning((object)($"Preview traps for {level} will be returned to queue." + "Applying new preview traps without previously discarding or promoting them should not be possible."));
				ClearTrapsList(ref _previewTraps, returnToQueue: true);
			}
			if (_activeTraps.Length != 0)
			{
				Plugin.Logger.LogWarning((object)($"Active traps for {level} will be returned to queue. " + "Applying new preview traps with currently active traps should not be possible."));
				ClearTrapsList(ref _activeTraps, returnToQueue: true);
			}
			_previewTraps = PopApplicableTraps(level);
			(int, ITrap)[] previewTraps = _previewTraps;
			for (int i = 0; i < previewTraps.Length; i++)
			{
				ITrap item = previewTraps[i].Item2;
				Plugin.Logger.LogInfo((object)("Invoking preview level for " + item.Name));
				item.PreviewLevel();
			}
			return _previewTraps;
		}

		internal IEnumerable<string> GetPreviewTrapNames()
		{
			List<string> list = new List<string>();
			(int, ITrap)[] previewTraps = _previewTraps;
			for (int i = 0; i < previewTraps.Length; i++)
			{
				ITrap item = previewTraps[i].Item2;
				list.Add(item.Name);
			}
			return list.AsReadOnly();
		}

		private void ClearPreviewTraps()
		{
			if (_previewTraps.Length == 0)
			{
				Plugin.Logger.LogWarning((object)"There must be at least one preview trap to clear.");
				return;
			}
			Plugin.Logger.LogInfo((object)"Clearing preview traps");
			(int, ITrap)[] previewTraps = _previewTraps;
			for (int i = 0; i < previewTraps.Length; i++)
			{
				ITrap item = previewTraps[i].Item2;
				Plugin.Logger.LogInfo((object)("Ending preview level for " + item.Name));
				item.PreviewLevelEnd();
			}
			ClearTrapsList(ref _previewTraps, returnToQueue: true);
		}

		private void OnLevelDeselected(object _, EventArgs __)
		{
			ClearPreviewTraps();
		}

		internal void ClearActiveTraps(bool returnToQueue)
		{
			Plugin.Logger.LogInfo((object)string.Format("[{0}] Clearing active traps (return to queue: {1})", "TrapManager", returnToQueue));
			if (_activeTraps.Length == 0)
			{
				Plugin.Logger.LogWarning((object)"[TrapManager] There must be at least one active trap to clear.");
				return;
			}
			(int, ITrap)[] activeTraps = _activeTraps;
			for (int i = 0; i < activeTraps.Length; i++)
			{
				var (num, trap) = activeTraps[i];
				trap.ActiveEnd();
				if (!returnToQueue && num != -1)
				{
					ClearedTraps[trap.Name]++;
					Plugin.Client.Session.DataStorage[(Scope)3, trap.Name] = DataStorageElement.op_Implicit(ClearedTraps[trap.Name]);
				}
			}
			ClearTrapsList(ref _activeTraps, returnToQueue);
		}

		internal void PromotePreviewTrapsToActiveTraps()
		{
			if (_previewTraps.Length == 0)
			{
				Plugin.Logger.LogWarning((object)"[TrapManager] There must be at least one trap under preview traps to promote to to an active trap,ignoring request to promote traps");
				return;
			}
			if (_activeTraps.Length != 0)
			{
				Plugin.Logger.LogError((object)"[TrapManager] There must be no active traps currently applied. Discarding old active traps.");
				ClearActiveTraps(returnToQueue: false);
			}
			_activeTraps = _previewTraps;
			_previewTraps = Array.Empty<(int, ITrap)>();
			(int, ITrap)[] activeTraps = _activeTraps;
			for (int i = 0; i < activeTraps.Length; i++)
			{
				ITrap item = activeTraps[i].Item2;
				Plugin.Logger.LogInfo((object)("[TrapManager] Invoking active for " + item.Name));
				item.Active();
			}
		}

		public void Dispose()
		{
			Plugin.Logger.LogInfo((object)"[TrapManager] Disposing");
			Events.Instance.LevelDeselected -= OnLevelDeselected;
			_gettingTrapClearedSemaphore.Dispose();
			(int, ITrap)[] activeTraps = _activeTraps;
			for (int i = 0; i < activeTraps.Length; i++)
			{
				activeTraps[i].Item2.ActiveEnd();
			}
			activeTraps = _previewTraps;
			for (int i = 0; i < activeTraps.Length; i++)
			{
				activeTraps[i].Item2.PreviewLevelEnd();
			}
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		public string Name { get; }

		public ExtensionMarkerAttribute(string name)
		{
			Name = name;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CompilerLoweringPreserveAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
}